Skip to content

AI turns documents or topics into real, native PowerPoint decks—with native shapes, transitions and animations, data-backed charts and tables on demand, audio narration from speaker notes, and support for your own .pptx templates. · by Hugo He

fix(ppt): improve PPTX/SVG round-trip fidelity

hugohe3888cd84fdb51
diff --git a/skills/ppt-master/scripts/pptx_template_import.py b/skills/ppt-master/scripts/pptx_template_import.py
index 495740c6..b7f9a900 100644
--- a/skills/ppt-master/scripts/pptx_template_import.py
+++ b/skills/ppt-master/scripts/pptx_template_import.py
@@ -129,6 +129,7 @@ def main() -> int:
embed_images=args.embed_images,
keep_hidden=False,
inheritance_mode=args.inheritance_mode,
+ asset_name_map=manifest.get("assets", {}).get("assetMap", {}) if manifest else {},
)
result = convert_pptx_to_svg(pptx_path, output_dir, options)
total_bytes = sum(len(art.svg.encode("utf-8")) for art in result.slides)
diff --git a/skills/ppt-master/scripts/pptx_to_svg.py b/skills/ppt-master/scripts/pptx_to_svg.py
index 2bf59c09..211507d0 100644
--- a/skills/ppt-master/scripts/pptx_to_svg.py
+++ b/skills/ppt-master/scripts/pptx_to_svg.py
@@ -4,13 +4,12 @@
Usage:
python3 pptx_to_svg.py <pptx_file> [-o <output_dir>] [--embed-images]
[--media-subdir <name>] [--keep-hidden]
+ [--inheritance-mode {both,layered,flat}]
-Output structure:
+Output structure (default --inheritance-mode both):
<output_dir>/
- svg/
- slide_01.svg
- slide_02.svg
- ...
+ svg/ layered machine input: masters/layouts/slides
+ svg-flat/ self-contained visual preview slides
<media_subdir>/ (default: assets/)
image1.png
image2.png
@@ -41,21 +40,36 @@ def parse_args() -> argparse.Namespace:
)
parser.add_argument("pptx_file", help="Path to the source .pptx file")
parser.add_argument(
- "-o", "--output",
+ "-o",
+ "--output",
help="Output directory (default: <pptx_stem>_pptx_to_svg beside source)",
)
parser.add_argument(
- "--media-subdir", default="assets",
+ "--media-subdir",
+ default="assets",
help="Subdirectory for extracted media (default: assets)",
)
parser.add_argument(
- "--embed-images", action="store_true",
+ "--embed-images",
+ action="store_true",
help="Base64-embed images inline instead of writing files",
)
parser.add_argument(
- "--keep-hidden", action="store_true",
+ "--keep-hidden",
+ action="store_true",
help='Include shapes marked hidden="1"',
)
+ parser.add_argument(
+ "--inheritance-mode",
+ choices=("both", "layered", "flat"),
+ default="both",
+ help=(
+ "How to render inheritance. 'both' (default) writes layered SVGs "
+ "under svg/ and complete preview slides under svg-flat/. "
+ "'layered' writes only svg/ plus inheritance.json. 'flat' writes "
+ "self-contained slides under svg/ for backward compatibility."
+ ),
+ )
return parser.parse_args()
@@ -66,12 +80,12 @@ def main() -> int:
print(f"Error: file does not exist: {pptx_path}", file=sys.stderr)
return 1
if pptx_path.suffix.lower() != ".pptx":
- print(f"Error: expected a .pptx file, got: {pptx_path.name}",
- file=sys.stderr)
+ print(f"Error: expected a .pptx file, got: {pptx_path.name}", file=sys.stderr)
return 1
output_dir = (
- Path(args.output).expanduser().resolve() if args.output
+ Path(args.output).expanduser().resolve()
+ if args.output
else pptx_path.with_name(f"{pptx_path.stem}_pptx_to_svg")
)
@@ -79,6 +93,7 @@ def main() -> int:
media_subdir=args.media_subdir,
embed_images=args.embed_images,
keep_hidden=args.keep_hidden,
+ inheritance_mode=args.inheritance_mode,
)
result = convert_pptx_to_svg(pptx_path, output_dir, options)
diff --git a/skills/ppt-master/scripts/pptx_to_svg/converter.py b/skills/ppt-master/scripts/pptx_to_svg/converter.py
index 4bc82af3..9045eed4 100644
--- a/skills/ppt-master/scripts/pptx_to_svg/converter.py
+++ b/skills/ppt-master/scripts/pptx_to_svg/converter.py
@@ -24,6 +24,46 @@ from .ooxml_loader import OoxmlPackage, PartRef, SlideRef
from .slide_to_svg import assemble_part_solo, assemble_slide
+def _extract_theme_info(
+ theme: PartRef,
+ palette: ColorPalette,
+) -> tuple[dict[str, str], dict[str, str]]:
+ from .color_resolver import find_color_elem, resolve_color
+
+ colors: dict[str, str] = {}
+ fonts: dict[str, str] = {}
+
+ scheme = theme.xml.find(".//a:clrScheme", NS)
+ if scheme is not None:
+ for child in list(scheme):
+ if not isinstance(child.tag, str):
+ continue
+ name = child.tag.split("}", 1)[-1]
+ color_elem = find_color_elem(child)
+ hex_, _ = resolve_color(color_elem, palette)
+ if hex_:
+ colors[name] = hex_
+
+ font_scheme = theme.xml.find(".//a:fontScheme", NS)
+ if font_scheme is not None:
+ for slot in ("majorFont", "minorFont"):
+ fnt = font_scheme.find(f"a:{slot}", NS)
+ if fnt is None:
+ continue
+ role_prefix = "major" if slot == "majorFont" else "minor"
+ latin = fnt.find("a:latin", NS)
+ if latin is not None and latin.attrib.get("typeface"):
+ fonts[f"{role_prefix}Latin"] = latin.attrib["typeface"]
+ ea = fnt.find("a:ea", NS)
+ if ea is not None and ea.attrib.get("typeface"):
+ fonts[f"{role_prefix}EastAsia"] = ea.attrib["typeface"]
+ cs = fnt.find("a:cs", NS)
+ if cs is not None and cs.attrib.get("typeface"):
+ fonts[f"{role_prefix}ComplexScript"] = cs.attrib["typeface"]
+
+ return colors, fonts
+
+
@dataclass
class ConvertOptions:
"""Convert behavior knobs.
@@ -51,6 +91,7 @@ class ConvertOptions:
embed_images: bool = False
keep_hidden: bool = False
inheritance_mode: str = "both"
+ asset_name_map: dict[str, str] = field(default_factory=dict)
@dataclass
@@ -62,6 +103,8 @@ class PartArtifact:
filename: str # output svg filename, e.g. "layout_03_title.xml.svg"
svg: str
media_files: dict[str, bytes] = field(default_factory=dict)
+ parent_master_part_path: str | None = None
+ theme_part_path: str | None = None
@dataclass
@@ -92,6 +135,7 @@ class ConvertResult:
layouts: list[PartArtifact] = field(default_factory=list)
masters: list[PartArtifact] = field(default_factory=list)
flat_slides: list[SlideArtifact] = field(default_factory=list)
+ master_themes: dict[str, dict[str, object]] = field(default_factory=dict)
# ---------------------------------------------------------------------------
@@ -127,63 +171,52 @@ def convert_pptx_to_svg(
with OoxmlPackage(pptx_path) as pkg:
result.canvas_px = pkg.slide_size_px
- # Theme + palette built once (multi-master case rarely happens in
- # template decks; if it does we re-resolve per slide).
+ # Default theme summary is kept for compatibility; conversion itself
+ # resolves palette/fonts per slide master.
first_slide = pkg.get_slide(1)
- master = first_slide.master if first_slide else None
- theme = pkg.resolve_theme(master)
- palette = ColorPalette(master, theme)
- if theme is not None:
- from .color_resolver import find_color_elem, resolve_color
- # Surface theme colors / fonts onto the result (informational only).
- scheme = theme.xml.find(".//a:clrScheme", NS)
- if scheme is not None:
- for child in list(scheme):
- if not isinstance(child.tag, str):
- continue
- name = child.tag.split("}", 1)[-1]
- color_elem = find_color_elem(child)
- hex_, _ = resolve_color(color_elem, palette)
- if hex_:
- result.theme_colors[name] = hex_
- font_scheme = theme.xml.find(".//a:fontScheme", NS)
- if font_scheme is not None:
- for slot in ("majorFont", "minorFont"):
- fnt = font_scheme.find(f"a:{slot}", NS)
- if fnt is None:
- continue
- role_prefix = "major" if slot == "majorFont" else "minor"
- latin = fnt.find("a:latin", NS)
- if latin is not None and latin.attrib.get("typeface"):
- result.theme_fonts[f"{role_prefix}Latin"] = latin.attrib["typeface"]
- ea = fnt.find("a:ea", NS)
- if ea is not None and ea.attrib.get("typeface"):
- result.theme_fonts[f"{role_prefix}EastAsia"] = ea.attrib["typeface"]
- cs = fnt.find("a:cs", NS)
- if cs is not None and cs.attrib.get("typeface"):
- result.theme_fonts[f"{role_prefix}ComplexScript"] = cs.attrib["typeface"]
+ default_master = first_slide.master if first_slide else None
+ default_theme = pkg.resolve_theme(default_master)
+ palette = ColorPalette(default_master, default_theme)
+ if default_theme is not None:
+ result.theme_colors, result.theme_fonts = _extract_theme_info(default_theme, palette)
+
+ for master in pkg.iter_all_masters():
+ theme = pkg.resolve_theme(master) or default_theme
+ pal = ColorPalette(master, theme)
+ colors, fonts = _extract_theme_info(theme, pal) if theme is not None else ({}, {})
+ result.master_themes[master.path] = {
+ "themePath": theme.path if theme is not None else None,
+ "colors": colors,
+ "fonts": fonts,
+ }
# Per-slide conversion. The primary view is layered when emitted
# (template designers care most about that one); the flat view is
# rendered alongside when needed.
primary_mode = "layered" if emit_layered else "flat"
for slide in pkg.iter_slides():
+ slide_theme = pkg.resolve_theme(slide.master) or default_theme
+ slide_palette = ColorPalette(slide.master, slide_theme)
+ _colors, slide_fonts = _extract_theme_info(slide_theme, slide_palette) if slide_theme is not None else ({}, result.theme_fonts)
artifact = _convert_slide(
- pkg, slide, palette, options, result.theme_fonts,
+ pkg, slide, slide_palette, options, slide_fonts,
inheritance_mode=primary_mode,
)
result.slides.append(artifact)
if emit_layered and emit_flat:
for slide in pkg.iter_slides():
+ slide_theme = pkg.resolve_theme(slide.master) or default_theme
+ slide_palette = ColorPalette(slide.master, slide_theme)
+ _colors, slide_fonts = _extract_theme_info(slide_theme, slide_palette) if slide_theme is not None else ({}, result.theme_fonts)
artifact = _convert_slide(
- pkg, slide, palette, options, result.theme_fonts,
+ pkg, slide, slide_palette, options, slide_fonts,
inheritance_mode="flat",
)
result.flat_slides.append(artifact)
# Layered mode: also render each master / layout once.
if emit_layered:
- _convert_inheritance_parts(pkg, palette, options, result)
+ _convert_inheritance_parts(pkg, default_theme, options, result)
if output_dir is not None:
_write_artifacts(output_dir, result, options)
@@ -218,6 +251,7 @@ def _convert_slide(
embed_images=options.embed_images,
keep_hidden=options.keep_hidden,
inheritance_mode=mode,
+ asset_name_map=options.asset_name_map,
)
return SlideArtifact(
index=slide.index,
@@ -230,7 +264,7 @@ def _convert_slide(
def _convert_inheritance_parts(
pkg: OoxmlPackage,
- palette: ColorPalette,
+ default_theme: PartRef | None,
options: ConvertOptions,
result: ConvertResult,
) -> None:
@@ -257,14 +291,21 @@ def _convert_inheritance_parts(
layouts_with_parent.append((layout, parent_master))
for seq, part in enumerate(seen_masters.values(), start=1):
+ theme = pkg.resolve_theme(part) or default_theme
+ palette = ColorPalette(part, theme)
+ _colors, fonts = _extract_theme_info(theme, palette) if theme is not None else ({}, result.theme_fonts)
result.masters.append(_render_part(
- pkg, part, palette, options, result.theme_fonts,
- role="master", seq=seq,
+ pkg, part, palette, options, fonts,
+ role="master", seq=seq, theme_part=theme,
))
for seq, (layout, parent_master) in enumerate(layouts_with_parent, start=1):
+ theme = pkg.resolve_theme(parent_master) or default_theme
+ palette = ColorPalette(parent_master, theme)
+ _colors, fonts = _extract_theme_info(theme, palette) if theme is not None else ({}, result.theme_fonts)
result.layouts.append(_render_part(
- pkg, layout, palette, options, result.theme_fonts,
+ pkg, layout, palette, options, fonts,
role="layout", seq=seq, parent_master=parent_master,
+ theme_part=theme,
))
@@ -278,6 +319,7 @@ def _render_part(
role: str,
seq: int,
parent_master: PartRef | None = None,
+ theme_part: PartRef | None = None,
) -> PartArtifact:
"""Render a master/layout part, returning a PartArtifact with output filename."""
svg, media = assemble_part_solo(
@@ -288,6 +330,7 @@ def _render_part(
media_subdir=options.media_subdir,
embed_images=options.embed_images,
keep_hidden=options.keep_hidden,
+ asset_name_map=options.asset_name_map,
)
stem = PurePosixPath(part.path).stem # e.g. "slideLayout3"
safe_stem = re.sub(r"[^A-Za-z0-9_-]+", "_", stem).strip("_") or role
@@ -298,6 +341,8 @@ def _render_part(
filename=filename,
svg=svg,
media_files=media,
+ parent_master_part_path=parent_master.path if parent_master is not None else None,
+ theme_part_path=theme_part.path if theme_part is not None else None,
)
@@ -321,7 +366,12 @@ def _write_artifacts(output_dir: Path, result: ConvertResult,
if filename in media_written:
continue
media_dir.mkdir(parents=True, exist_ok=True)
- (media_dir / filename).write_bytes(blob)
+ target = media_dir / filename
+ if target.exists():
+ if target.read_bytes() != blob:
+ raise RuntimeError(f"Asset filename collision with different bytes: {filename}")
+ else:
+ target.write_bytes(blob)
media_written.add(filename)
# Layered mode: write masters and layouts first so they sort ahead of slides.
@@ -357,23 +407,23 @@ def _write_inheritance_json(svg_dir: Path, result: ConvertResult) -> None:
"""Record which layout/master each slide consumes (layered mode only)."""
layout_by_path = {art.part_path: art.filename for art in result.layouts}
master_by_path = {art.part_path: art.filename for art in result.masters}
- layout_to_master: dict[str, str | None] = {}
- # We don't have the part->parent map from OoxmlPackage here directly, so
- # derive it from slides.
- for slide in result.slides:
- if slide.layout_part_path and slide.layout_part_path not in layout_to_master:
- layout_to_master[slide.layout_part_path] = slide.master_part_path
inheritance = {
"masters": [
- {"file": art.filename, "partPath": art.part_path}
+ {
+ "file": art.filename,
+ "partPath": art.part_path,
+ "themePath": art.theme_part_path,
+ }
for art in result.masters
],
"layouts": [
{
"file": art.filename,
"partPath": art.part_path,
- "master": master_by_path.get(layout_to_master.get(art.part_path) or ""),
+ "master": master_by_path.get(art.parent_master_part_path or ""),
+ "parentPartPath": art.parent_master_part_path,
+ "themePath": art.theme_part_path,
}
for art in result.layouts
],
diff --git a/skills/ppt-master/scripts/pptx_to_svg/pic_to_svg.py b/skills/ppt-master/scripts/pptx_to_svg/pic_to_svg.py
index 48f79385..ed383231 100644
--- a/skills/ppt-master/scripts/pptx_to_svg/pic_to_svg.py
+++ b/skills/ppt-master/scripts/pptx_to_svg/pic_to_svg.py
@@ -31,7 +31,11 @@ import base64
import hashlib
import io
import mimetypes
+import shutil
+import subprocess
+import tempfile
from dataclasses import dataclass, field
+from pathlib import Path
from xml.etree import ElementTree as ET
try:
@@ -54,6 +58,10 @@ class PictureResult:
media: dict[str, bytes] = field(default_factory=dict)
+class MediaResolutionError(RuntimeError):
+ """Raised when a PPTX media relationship cannot be reproduced as SVG."""
+
+
def convert_blip_fill(
blip_fill_elem: ET.Element,
xfrm: Xfrm,
@@ -62,6 +70,7 @@ def convert_blip_fill(
*,
media_subdir: str = "assets",
embed_inline: bool = False,
+ asset_name_map: dict[str, str] | None = None,
) -> PictureResult:
"""Convert an <a:blipFill> element to SVG <image>.
@@ -74,19 +83,25 @@ def convert_blip_fill(
return PictureResult()
rid = blip.attrib.get(f"{{{NS['r']}}}embed")
+ linked_rid = blip.attrib.get(f"{{{NS['r']}}}link")
if not rid:
+ if linked_rid:
+ raise MediaResolutionError(
+ "Linked image relationships are not supported; embed the image in PowerPoint first"
+ )
return PictureResult()
target = slide_part.resolve_rel(rid)
if not target:
- return PictureResult()
+ raise MediaResolutionError(f"Image relationship {rid} cannot be resolved in {slide_part.path}")
# Read the bytes
img_bytes = pkg.read_media(target)
if img_bytes is None:
- return PictureResult()
+ raise MediaResolutionError(f"Embedded image part is missing: {target}")
- filename = pkg.media_filename(target)
+ filename = (asset_name_map or {}).get(target, pkg.media_filename(target))
+ filename, img_bytes = _normalize_office_media(filename, img_bytes)
filename, img_bytes = _apply_blip_image_effects(filename, img_bytes, blip)
href = _build_href(filename, img_bytes, media_subdir, embed_inline)
@@ -135,6 +150,7 @@ def convert_picture(
*,
media_subdir: str = "assets",
embed_inline: bool = False,
+ asset_name_map: dict[str, str] | None = None,
) -> PictureResult:
"""Translate <p:pic> to SVG <image> (or nested <svg>+<image> for cropping)."""
blip_fill = pic_elem.find("p:blipFill", NS)
@@ -145,6 +161,7 @@ def convert_picture(
blip_fill, xfrm, slide_part, pkg,
media_subdir=media_subdir,
embed_inline=embed_inline,
+ asset_name_map=asset_name_map,
)
@@ -152,6 +169,52 @@ def convert_picture(
# Helpers
# ---------------------------------------------------------------------------
+_OFFICE_VECTOR_EXTS = {".emf", ".wmf"}
+
+
+def _normalize_office_media(filename: str, img_bytes: bytes) -> tuple[str, bytes]:
+ """Convert Office-only vector image formats to browser-renderable PNG.
+
+ PPTX can contain EMF/WMF assets that PowerPoint renders natively but SVG
+ viewers generally do not. Keep the original asset in the manifest layer;
+ the SVG view uses a PNG preview when the local system can make one.
+ """
+ suffix = Path(filename).suffix.lower()
+ if suffix not in _OFFICE_VECTOR_EXTS:
+ return filename, img_bytes
+
+ converted = _convert_office_vector_to_png(filename, img_bytes)
+ if converted is None:
+ raise MediaResolutionError(
+ f"Unsupported Office vector media {filename}; convert it to PNG/SVG in PowerPoint first"
+ )
+ stem = Path(filename).stem
+ return f"{stem}_preview.png", converted
+
+
+def _convert_office_vector_to_png(filename: str, img_bytes: bytes) -> bytes | None:
+ magick = shutil.which("magick")
+ if not magick:
+ return None
+ suffix = Path(filename).suffix.lower() or ".bin"
+ with tempfile.TemporaryDirectory() as tmp:
+ tmp_dir = Path(tmp)
+ src = tmp_dir / f"source{suffix}"
+ dst = tmp_dir / "preview.png"
+ src.write_bytes(img_bytes)
+ try:
+ subprocess.run(
+ [magick, str(src), str(dst)],
+ check=True,
+ stdout=subprocess.DEVNULL,
+ stderr=subprocess.DEVNULL,
+ )
+ except (OSError, subprocess.CalledProcessError):
+ return None
+ if not dst.exists():
+ return None
+ return dst.read_bytes()
+
def _parse_src_rect(elem: ET.Element | None) -> tuple[float, float, float, float] | None:
"""Convert <a:srcRect l t r b="1/100000"/> to (x, y, w, h) in unit space."""
if elem is None:
diff --git a/skills/ppt-master/scripts/pptx_to_svg/slide_to_svg.py b/skills/ppt-master/scripts/pptx_to_svg/slide_to_svg.py
index 3a98a298..d67021ed 100644
--- a/skills/ppt-master/scripts/pptx_to_svg/slide_to_svg.py
+++ b/skills/ppt-master/scripts/pptx_to_svg/slide_to_svg.py
@@ -63,6 +63,8 @@ class AssemblyContext:
embed_images: bool = False
keep_hidden: bool = False
group_id_prefix: str = ""
+ render_graphic_previews: bool = True
+ asset_name_map: dict[str, str] = field(default_factory=dict)
# Sequence counters (single-element lists so handlers can mutate)
grad_seq: list[int] = field(default_factory=lambda: [0])
@@ -90,6 +92,7 @@ def assemble_slide(
embed_images: bool = False,
keep_hidden: bool = False,
inheritance_mode: str = "flat",
+ asset_name_map: dict[str, str] | None = None,
) -> tuple[str, dict[str, bytes]]:
"""Convert one slide to a complete SVG string + media files map.
@@ -110,13 +113,22 @@ def assemble_slide(
media_subdir=media_subdir,
embed_images=embed_images,
keep_hidden=keep_hidden,
+ render_graphic_previews=(inheritance_mode == "flat"),
+ asset_name_map=asset_name_map or {},
)
canvas_w, canvas_h = pkg.slide_size_px
# Background (cSld/bg) — emit as the first body element.
body_parts: list[str] = []
- bg_xml = _emit_background(slide, ctx, canvas_w, canvas_h)
+ bg_xml = (
+ _emit_background(slide, ctx, canvas_w, canvas_h)
+ if inheritance_mode == "flat"
+ else _emit_part_background(
+ SlideRef(index=slide.index, part=slide.part, layout=None, master=slide.master),
+ ctx, canvas_w, canvas_h,
+ )
+ )
if bg_xml:
body_parts.append(bg_xml)
@@ -168,6 +180,7 @@ def assemble_part_solo(
media_subdir: str = "assets",
embed_images: bool = False,
keep_hidden: bool = False,
+ asset_name_map: dict[str, str] | None = None,
) -> tuple[str, dict[str, bytes]]:
"""Render a single slideMaster or slideLayout part as a standalone SVG.
@@ -198,6 +211,8 @@ def assemble_part_solo(
embed_images=embed_images,
keep_hidden=keep_hidden,
group_id_prefix=f"{role}-",
+ render_graphic_previews=False,
+ asset_name_map=asset_name_map or {},
)
canvas_w, canvas_h = pkg.slide_size_px
@@ -225,11 +240,13 @@ def assemble_part_solo(
if bg_xml:
body_parts.append(bg_xml)
- # Walk shapes, skipping placeholders (consistent with _emit_inherited_shapes).
+ # Walk shapes. Placeholders are visualized as lightweight layout guides in
+ # layered master/layout SVGs so template slots remain machine-visible.
for node in walk_sp_tree(part.xml):
if _is_placeholder_node(node):
- continue
- chunk = _convert_node(node, ctx, top_level=True)
+ chunk = _convert_placeholder_guide(node, ctx, top_level=True)
+ else:
+ chunk = _convert_node(node, ctx, top_level=True)
if chunk:
body_parts.append(chunk)
@@ -286,6 +303,7 @@ def _convert_shape(node: ShapeNode, ctx: AssemblyContext, *, top_level: bool) ->
blip_fill_elem, node.xfrm, ctx.slide_part, ctx.pkg,
media_subdir=ctx.media_subdir,
embed_inline=ctx.embed_images,
+ asset_name_map=ctx.asset_name_map,
)
if blip_result.svg:
blip_image = _clip_blip_image(blip_result.svg, geom, ctx)
@@ -383,6 +401,9 @@ def _build_geometry_xml(node: ShapeNode, sp_pr: ET.Element | None,
ctx.defs.extend(effect_defs)
attrs = {**fill.attrs, **stroke.attrs}
+ style_defaults = _resolve_shape_style_defaults(node, ctx)
+ for key, value in style_defaults.items():
+ attrs.setdefault(key, value)
if filter_id is not None:
attrs["filter"] = f"url(#{filter_id})"
@@ -390,9 +411,6 @@ def _build_geometry_xml(node: ShapeNode, sp_pr: ET.Element | None,
# behavior: a:noFill on shape-level fill if there's a txBody, else any
# explicit fill present in spPr should already have been captured).
if "fill" not in attrs:
- # Default: transparent so the shape doesn't paint over text/images.
- # PowerPoint's actual default is theme accent + style, but mimicking
- # that requires reading slideMaster styles which is out of v1 scope.
attrs["fill"] = "none"
if "stroke" not in attrs:
# Spec default for shapes is no stroke unless ln says otherwise.
@@ -403,6 +421,39 @@ def _build_geometry_xml(node: ShapeNode, sp_pr: ET.Element | None,
return _geom_to_svg(geom, geom_attrs_xml)
+def _resolve_shape_style_defaults(node: ShapeNode, ctx: AssemblyContext) -> dict[str, str]:
+ """Resolve minimal p:style defaults used when spPr omits explicit style.
+
+ Full theme style matrix reproduction is intentionally out of scope here;
+ this only prevents common theme-styled placeholders/shapes from becoming
+ transparent or unstroked when their visible color lives in p:style.
+ """
+ style = node.xml.find("p:style", NS)
+ if style is None:
+ return {}
+
+ defaults: dict[str, str] = {}
+
+ fill_ref = style.find("a:fillRef", NS)
+ fill_color = _resolve_ref_color(fill_ref, ctx)
+ if fill_color:
+ defaults["fill"] = fill_color
+
+ ln_ref = style.find("a:lnRef", NS)
+ line_color = _resolve_ref_color(ln_ref, ctx)
+ if line_color:
+ defaults["stroke"] = line_color
+ defaults.setdefault("stroke-width", "1")
+
+ return defaults
+
+
+def _resolve_ref_color(ref_elem: ET.Element | None, ctx: AssemblyContext) -> str | None:
+ color_elem = find_color_elem(ref_elem)
+ hex_, _alpha = resolve_color(color_elem, ctx.palette)
+ return hex_
+
+
def _geom_to_svg(geom: GeomResult, attrs_xml: str = "") -> str:
"""Serialize a resolved geometry with optional SVG attributes."""
if not attrs_xml:
@@ -437,7 +488,7 @@ def _inject_clip_path(image_xml: str, clip_id: str) -> str:
if image_xml.startswith("<image"):
return image_xml.replace("<image", f"<image{clip_attr}", 1)
if image_xml.startswith("<svg"):
- return image_xml.replace("<svg", f"<svg{clip_attr}", 1)
+ return image_xml.replace("<svg", f'<svg data-pptx-crop="1"{clip_attr}', 1)
return image_xml
@@ -450,6 +501,7 @@ def _convert_picture(node: ShapeNode, ctx: AssemblyContext, *, top_level: bool)
node.xml, node.xfrm, ctx.slide_part, ctx.pkg,
media_subdir=ctx.media_subdir,
embed_inline=ctx.embed_images,
+ asset_name_map=ctx.asset_name_map,
)
if not result.svg:
return ""
@@ -509,10 +561,17 @@ def _convert_graphic_fallback(node: ShapeNode, ctx: AssemblyContext,
if rendered:
return _wrap_shape_group(rendered, node, ctx, top_level=top_level)
- if uri == "http://schemas.openxmlformats.org/presentationml/2006/ole":
- rendered = _render_ole_preview(node, ctx)
+ if uri == "http://schemas.openxmlformats.org/presentationml/2006/ole" and ctx.render_graphic_previews:
+ rendered = _render_graphic_preview(node, ctx)
if rendered:
- return _wrap_shape_group(rendered, node, ctx, top_level=top_level)
+ labelled = rendered + "\n" + _graphic_preview_label(node, "ole preview")
+ return _wrap_shape_group(labelled, node, ctx, top_level=top_level)
+
+ if ctx.render_graphic_previews:
+ rendered = _render_graphic_preview(node, ctx)
+ if rendered:
+ labelled = rendered + "\n" + _graphic_preview_label(node, f"{uri.rsplit('/', 1)[-1]} preview")
+ return _wrap_shape_group(labelled, node, ctx, top_level=top_level)
label = uri.rsplit("/", 1)[-1]
placeholder = (
@@ -527,6 +586,16 @@ def _convert_graphic_fallback(node: ShapeNode, ctx: AssemblyContext,
return _wrap_shape_group(placeholder, node, ctx, top_level=top_level)
+def _graphic_preview_label(node: ShapeNode, label: str) -> str:
+ return (
+ f'<rect x="{fmt_num(node.xfrm.x)}" y="{fmt_num(node.xfrm.y)}" '
+ f'width="{fmt_num(node.xfrm.w)}" height="22" '
+ f'fill="#FFFFFF" fill-opacity="0.82" stroke="#999999" stroke-width="0.5"/>'
+ f'<text x="{fmt_num(node.xfrm.x + 6)}" y="{fmt_num(node.xfrm.y + 15)}" '
+ f'font-size="11" fill="#666666">[{_xml_escape(label)}]</text>'
+ )
+
+
def _render_graphic_table(node: ShapeNode, ctx: AssemblyContext,
graphic_data: ET.Element | None) -> str:
"""Convert the <a:tbl> child of a graphicFrame to SVG, or return ''."""
@@ -547,17 +616,13 @@ def _render_graphic_table(node: ShapeNode, ctx: AssemblyContext,
return result.svg
-def _render_ole_preview(node: ShapeNode, ctx: AssemblyContext) -> str:
- """Render an OLE-embedded object as its baked preview bitmap.
+def _render_graphic_preview(node: ShapeNode, ctx: AssemblyContext) -> str:
+ """Render a graphicFrame's baked fallback preview bitmap when present.
- PowerPoint stores a static raster preview for every embedded OLE object
- inside ``mc:AlternateContent``. The Fallback branch is required by spec
- to be a plain ``p:pic`` (sometimes nested inside a stray ``p:oleObj``),
- so any conformant viewer that can't speak OLE just paints the preview.
- We do the same: locate that ``p:pic`` and run it through the regular
- picture pipeline. The user sees what they'd see in PowerPoint without
- double-clicking the chart, no live OLE editing required (which we
- couldn't do in SVG anyway).
+ PowerPoint stores a static raster preview for many embedded graphics
+ inside ``mc:AlternateContent``. The Fallback branch is normally a plain
+ ``p:pic`` (sometimes nested), so any conformant viewer that can't speak
+ the richer object paints the preview. We do the same for flat preview SVGs.
Falls back to '' when the deck has no Fallback pic (very old or
third-party authoring tools sometimes omit it). Caller then emits the
@@ -589,6 +654,7 @@ def _render_ole_preview(node: ShapeNode, ctx: AssemblyContext) -> str:
pic, inner_xfrm, ctx.slide_part, ctx.pkg,
media_subdir=ctx.media_subdir,
embed_inline=ctx.embed_images,
+ asset_name_map=ctx.asset_name_map,
)
if not result.svg:
return ""
@@ -700,6 +766,7 @@ def _emit_background_image(
ctx.pkg,
media_subdir=ctx.media_subdir,
embed_inline=ctx.embed_images,
+ asset_name_map=ctx.asset_name_map,
)
if result.media:
ctx.media.update(result.media)
@@ -766,6 +833,28 @@ def _is_placeholder_node(node: ShapeNode) -> bool:
return False
+def _convert_placeholder_guide(node: ShapeNode, ctx: AssemblyContext,
+ *, top_level: bool) -> str:
+ """Emit a lightweight visible guide for template placeholder slots."""
+ ph = node.placeholder
+ label_parts = ["ph"]
+ if ph is not None:
+ if ph.type:
+ label_parts.append(ph.type)
+ if ph.idx:
+ label_parts.append(f"idx={ph.idx}")
+ label = " ".join(label_parts)
+ guide = (
+ f'<rect x="{fmt_num(node.xfrm.x)}" y="{fmt_num(node.xfrm.y)}" '
+ f'width="{fmt_num(node.xfrm.w)}" height="{fmt_num(node.xfrm.h)}" '
+ f'fill="#F8FAFC" fill-opacity="0.18" stroke="#94A3B8" '
+ f'stroke-dasharray="6 4" stroke-width="1"/>'
+ f'<text x="{fmt_num(node.xfrm.x + 8)}" y="{fmt_num(node.xfrm.y + 18)}" '
+ f'font-size="12" fill="#64748B">{_xml_escape(label)}</text>'
+ )
+ return _wrap_shape_group(guide, node, ctx, top_level=top_level)
+
+
# ---------------------------------------------------------------------------
# Wrap / utilities
# ---------------------------------------------------------------------------
diff --git a/skills/ppt-master/scripts/pptx_to_svg/txbody_to_svg.py b/skills/ppt-master/scripts/pptx_to_svg/txbody_to_svg.py
index fc050122..ed80f51a 100644
--- a/skills/ppt-master/scripts/pptx_to_svg/txbody_to_svg.py
+++ b/skills/ppt-master/scripts/pptx_to_svg/txbody_to_svg.py
@@ -13,8 +13,8 @@ Strategy (v1):
text frame plus lIns/rIns and the alignment.
- No automatic word wrap (PPT's wrap is layout-time; v1 trusts the existing
text frame width and emits text as-is). a:br produces an explicit linebreak.
-- Bullet points (a:buChar / a:buAutoNum) are NOT rendered as PPT bullet
- glyphs — instead we prepend a literal '• ' / 'N. ' so the visual lands.
+- Bullet points (a:buChar / a:buAutoNum) are rendered as literal prefixes
+ so the visual lands without relying on PowerPoint list semantics.
Color / font / size attributes propagate from a:rPr; missing attributes fall
back to the paragraph's endParaRPr or to spec-default values.
@@ -278,9 +278,10 @@ def _parse_paragraphs(
) -> list[TextParagraph]:
"""Walk <a:p> children producing TextParagraph objects."""
paragraphs: list[TextParagraph] = []
+ autonum_state: dict[int, int] = {}
for p_elem in tx_body.findall("a:p", NS):
- para = _parse_paragraph(p_elem, palette, theme_fonts)
+ para = _parse_paragraph(p_elem, palette, theme_fonts, autonum_state)
paragraphs.append(para)
return paragraphs
@@ -290,6 +291,7 @@ def _parse_paragraph(
p_elem: ET.Element,
palette: ColorPalette | None,
theme_fonts: dict[str, str],
+ autonum_state: dict[int, int],
) -> TextParagraph:
para = TextParagraph()
@@ -329,8 +331,8 @@ def _parse_paragraph(
except ValueError:
pass
- # Bullet
- para.bullet_prefix = _resolve_bullet_prefix(p_pr)
+ # Bullet / basic auto-numbering
+ para.bullet_prefix = _resolve_bullet_prefix(p_pr, para.level, autonum_state)
# Default endParaRPr style (applies if a run has no rPr)
end_rpr = p_elem.find("a:endParaRPr", NS)
@@ -500,10 +502,15 @@ def _quote_font(name: str) -> str:
return name
-def _resolve_bullet_prefix(p_pr: ET.Element) -> str:
+def _resolve_bullet_prefix(
+ p_pr: ET.Element,
+ level: int,
+ autonum_state: dict[int, int],
+) -> str:
"""Render bullet glyphs / numbering as a literal text prefix."""
bu_none = p_pr.find("a:buNone", NS)
if bu_none is not None:
+ autonum_state.pop(level, None)
return ""
bu_char = p_pr.find("a:buChar", NS)
if bu_char is not None:
@@ -511,12 +518,68 @@ def _resolve_bullet_prefix(p_pr: ET.Element) -> str:
return f"{ch} "
bu_auto = p_pr.find("a:buAutoNum", NS)
if bu_auto is not None:
- # Type-aware numbering (arabicPeriod / romanLcParenR / etc.) is too
- # ambiguous without paragraph history; use a placeholder.
- return "• "
+ start_at = bu_auto.attrib.get("startAt")
+ if start_at is not None:
+ try:
+ autonum_state[level] = int(start_at)
+ except ValueError:
+ autonum_state[level] = 1
+ else:
+ autonum_state[level] = autonum_state.get(level, 0) + 1
+ return _format_auto_number(
+ autonum_state[level],
+ bu_auto.attrib.get("type", "arabicPeriod"),
+ )
return ""
+def _format_auto_number(value: int, kind: str) -> str:
+ lower = kind.lower()
+ if "alphalc" in lower:
+ token = _alpha_number(value, uppercase=False)
+ elif "alphauc" in lower:
+ token = _alpha_number(value, uppercase=True)
+ elif "romanlc" in lower:
+ token = _roman_number(value).lower()
+ elif "romanuc" in lower:
+ token = _roman_number(value).upper()
+ else:
+ token = str(value)
+
+ if "parenboth" in lower:
+ return f"({token}) "
+ if "parenr" in lower:
+ return f"{token}) "
+ if "period" in lower:
+ return f"{token}. "
+ return f"{token} "
+
+
+def _alpha_number(value: int, *, uppercase: bool) -> str:
+ value = max(1, value)
+ chars: list[str] = []
+ while value:
+ value -= 1
+ chars.append(chr(ord("A") + (value % 26)))
+ value //= 26
+ text = "".join(reversed(chars))
+ return text if uppercase else text.lower()
+
+
+def _roman_number(value: int) -> str:
+ value = max(1, min(value, 3999))
+ parts: list[str] = []
+ for n, token in (
+ (1000, "M"), (900, "CM"), (500, "D"), (400, "CD"),
+ (100, "C"), (90, "XC"), (50, "L"), (40, "XL"),
+ (10, "X"), (9, "IX"), (5, "V"), (4, "IV"), (1, "I"),
+ ):
+ while value >= n:
+ parts.append(token)
+ value -= n
+ return "".join(parts)
+
+
# ---------------------------------------------------------------------------
# Layout / emission
# ---------------------------------------------------------------------------
diff --git a/skills/ppt-master/scripts/svg_quality_checker.py b/skills/ppt-master/scripts/svg_quality_checker.py
index fcb8ba00..d766e131 100644
--- a/skills/ppt-master/scripts/svg_quality_checker.py
+++ b/skills/ppt-master/scripts/svg_quality_checker.py
@@ -323,17 +323,21 @@ class SVGQualityChecker:
# ============================================================
# Clipping / masking
- # clipPath is ONLY allowed on <image> elements (converter maps to DrawingML
- # picture geometry). On shapes it is pointless (just draw the target shape)
- # and breaks the SVG PPTX rendering.
+ # clipPath is allowed on <image> elements and on pptx_to_svg-generated
+ # nested crop <svg data-pptx-crop="1"> wrappers. Both map back to
+ # DrawingML picture geometry in the native converter.
if '<clippath' in content_lower:
# clip-path on non-image elements → error
clip_on_non_image = re.search(
- r'<(?!image\b)\w+[^>]*\bclip-path\s*=', content, re.IGNORECASE)
+ r'<(?!image\b)(?!svg\b[^>]*\bdata-pptx-crop\s*=\s*["\']1["\'])\w+[^>]*\bclip-path\s*=',
+ content,
+ re.IGNORECASE,
+ )
if clip_on_non_image:
result['errors'].append(
- "clip-path is only allowed on <image> elements — "
- "for shapes, draw the target shape directly instead of clipping")
+ "clip-path is only allowed on <image> elements or "
+ "pptx_to_svg crop wrappers — for shapes, draw the target "
+ "shape directly instead of clipping")
# Check that every clip-path reference has a matching <clipPath> def
clip_refs = re.findall(r'clip-path\s*=\s*["\']url\(#([^)]+)\)', content)
for ref_id in clip_refs:
diff --git a/skills/ppt-master/scripts/svg_to_pptx/drawingml_converter.py b/skills/ppt-master/scripts/svg_to_pptx/drawingml_converter.py
index d4a33cb8..d5236683 100644
--- a/skills/ppt-master/scripts/svg_to_pptx/drawingml_converter.py
+++ b/skills/ppt-master/scripts/svg_to_pptx/drawingml_converter.py
@@ -20,6 +20,10 @@ from .drawingml_elements import (
)
+class SvgNativeConversionError(RuntimeError):
+ """Raised when an SVG cannot be faithfully converted to native DrawingML."""
+
+
# ---------------------------------------------------------------------------
# Animation anchor selection
# ---------------------------------------------------------------------------
@@ -240,6 +244,8 @@ _CONVERTERS = {
'svg': convert_nested_svg,
}
+_SUPPORTED_VISUAL_CHILD_TAGS = frozenset(('tspan',))
+
def collect_defs(root: ET.Element) -> dict[str, ET.Element]:
"""Collect all <defs> children into an {id: element} dictionary."""
@@ -267,13 +273,38 @@ def convert_element(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None
try:
return converter(elem, ctx)
except Exception as e:
- print(f' Warning: Failed to convert <{tag}>: {e}')
- return None
+ raise SvgNativeConversionError(f'Failed to convert <{tag}>: {e}') from e
if tag in _NON_VISUAL_TAGS:
return None
- return None
+ raise SvgNativeConversionError(f'Unsupported visual SVG element <{tag}>')
+
+
+def _local_tag(elem: ET.Element) -> str:
+ return elem.tag.split('}', 1)[-1] if isinstance(elem.tag, str) and '}' in elem.tag else str(elem.tag)
+
+
+def _collect_unsupported_visuals(root: ET.Element) -> list[str]:
+ issues: list[str] = []
+
+ def walk(elem: ET.Element, path: str, in_defs: bool = False) -> None:
+ tag = _local_tag(elem)
+ current = f'{path}/{tag}'
+ if in_defs:
+ return
+ if tag in _NON_VISUAL_TAGS:
+ return
+ if (tag not in _CONVERTERS
+ and tag not in _NON_VISUAL_TAGS
+ and tag not in _SUPPORTED_VISUAL_CHILD_TAGS):
+ issues.append(current)
+ for idx, child in enumerate(list(elem), start=1):
+ walk(child, f'{current}[{idx}]', in_defs=(tag == 'defs'))
+
+ for idx, child in enumerate(list(root), start=1):
+ walk(child, f'/svg[{idx}]')
+ return issues
def convert_svg_to_slide_shapes(
@@ -322,6 +353,14 @@ def convert_svg_to_slide_shapes(
if flatten_positional_tspans(tree) and verbose:
print(' Flattened positional <tspan> into independent <text>')
+ unsupported = _collect_unsupported_visuals(root)
+ if unsupported:
+ preview = '; '.join(unsupported[:8])
+ suffix = '' if len(unsupported) <= 8 else f'; +{len(unsupported) - 8} more'
+ raise SvgNativeConversionError(
+ f'{svg_path.name}: unsupported visual SVG element(s): {preview}{suffix}'
+ )
+
defs = collect_defs(root)
ctx = ConvertContext(defs=defs, slide_num=slide_num, svg_dir=Path(svg_path).parent)
diff --git a/skills/ppt-master/scripts/svg_to_pptx/drawingml_elements.py b/skills/ppt-master/scripts/svg_to_pptx/drawingml_elements.py
index d435e5b6..b5c3845b 100644
--- a/skills/ppt-master/scripts/svg_to_pptx/drawingml_elements.py
+++ b/skills/ppt-master/scripts/svg_to_pptx/drawingml_elements.py
@@ -1459,10 +1459,12 @@ def convert_image(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
# Extract image data
if href.startswith('data:'):
- match = re.match(r'data:image/(\w+);base64,(.+)', href, re.DOTALL)
+ match = re.match(r'data:image/([A-Za-z0-9.+-]+);base64,(.+)', href, re.DOTALL)
if not match:
return None
img_format = match.group(1).lower()
+ if img_format == 'svg+xml':
+ img_format = 'svg'
if img_format == 'jpeg':
img_format = 'jpg'
img_data = base64.b64decode(match.group(2))
@@ -1473,8 +1475,7 @@ def convert_image(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
if not img_path.exists():
img_path = ctx.svg_dir.parent / href
if not img_path.exists():
- print(f' Warning: External image not found: {href}')
- return None
+ raise FileNotFoundError(f'External image not found: {href}')
img_format = img_path.suffix.lstrip('.').lower()
if img_format == 'jpeg':
img_format = 'jpg'
@@ -1657,10 +1658,12 @@ def convert_nested_svg(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | N
src_rect_xml = f'<a:srcRect l="{l}" t="{t}" r="{r}" b="{b}"/>'
if href.startswith('data:'):
- match = re.match(r'data:image/(\w+);base64,(.+)', href, re.DOTALL)
+ match = re.match(r'data:image/([A-Za-z0-9.+-]+);base64,(.+)', href, re.DOTALL)
if not match:
return None
img_format = match.group(1).lower()
+ if img_format == 'svg+xml':
+ img_format = 'svg'
if img_format == 'jpeg':
img_format = 'jpg'
img_data = base64.b64decode(match.group(2))
@@ -1671,8 +1674,7 @@ def convert_nested_svg(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | N
if not img_path.exists():
img_path = ctx.svg_dir.parent / href
if not img_path.exists():
- print(f' Warning: External image not found: {href}')
- return None
+ raise FileNotFoundError(f'External image not found: {href}')
img_format = img_path.suffix.lstrip('.').lower()
if img_format == 'jpeg':
img_format = 'jpg'
@@ -1703,6 +1705,7 @@ def convert_nested_svg(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | N
)
if rot_attr:
xfrm_attr += rot_attr
+ clip_geom = _resolve_clip_geometry(elem, ctx, svg_x, svg_y, svg_w, svg_h)
return ShapeResult(xml=f'''<p:pic>
<p:nvPicPr>
@@ -1717,6 +1720,6 @@ def convert_nested_svg(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | N
<p:spPr>
<a:xfrm{xfrm_attr}><a:off x="{off_x}" y="{off_y}"/>
<a:ext cx="{ext_cx}" cy="{ext_cy}"/></a:xfrm>
-<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>
+{clip_geom}
</p:spPr>
</p:pic>''', bounds_emu=bounds_emu)
diff --git a/skills/ppt-master/scripts/svg_to_pptx/pptx_builder.py b/skills/ppt-master/scripts/svg_to_pptx/pptx_builder.py
index 467bd049..a0f4c77c 100644
--- a/skills/ppt-master/scripts/svg_to_pptx/pptx_builder.py
+++ b/skills/ppt-master/scripts/svg_to_pptx/pptx_builder.py
@@ -3,6 +3,7 @@
from __future__ import annotations
import hashlib
+import mimetypes
import re
import shutil
import tempfile
@@ -90,6 +91,27 @@ def _add_default_content_type(content_types: str, extension: str, content_type:
return content_types.replace('</Types>', entry + '\n</Types>')
+_IMAGE_CONTENT_TYPES = {
+ 'png': 'image/png',
+ 'jpg': 'image/jpeg',
+ 'jpeg': 'image/jpeg',
+ 'gif': 'image/gif',
+ 'webp': 'image/webp',
+ 'svg': 'image/svg+xml',
+ 'bmp': 'image/bmp',
+ 'tif': 'image/tiff',
+ 'tiff': 'image/tiff',
+}
+
+
+def _content_type_for_extension(ext: str) -> str:
+ clean = ext.lower().lstrip('.')
+ content_type = _IMAGE_CONTENT_TYPES.get(clean) or mimetypes.guess_type(f'x.{clean}')[0]
+ if not content_type:
+ raise ValueError(f"Unknown media content type for extension: {ext}")
+ return content_type
+
+
def _expand_anim_targets_to_group_children(
slide_xml: str,
anim_targets: list[tuple[int, str]],
@@ -273,6 +295,7 @@ def create_pptx_with_native_svg(
success_count = 0
has_any_image = False
media_cache: dict[tuple[str, str], str] = {}
+ image_exts_used: set[str] = set()
notes_slides_created: set[int] = set()
narration_slides_created: set[int] = set()
audio_exts_used: set[str] = set()
@@ -343,7 +366,7 @@ def create_pptx_with_native_svg(
cached_name = media_cache.get(cache_key)
if cached_name is None:
- cached_name = media_name
+ cached_name = f'image_{media_hash[:16]}.{ext}'
media_cache[cache_key] = cached_name
with open(media_dir / cached_name, 'wb') as f:
f.write(media_data)
@@ -379,10 +402,11 @@ def create_pptx_with_native_svg(
f.write(rels_xml)
# Track image formats for Content_Types
- for media_name in media_files_dict:
+ for media_name in media_name_map.values():
ext = media_name.rsplit('.', 1)[-1].lower()
- if ext in ('png', 'jpg', 'jpeg', 'gif', 'webp'):
- has_any_image = True
+ _content_type_for_extension(ext)
+ image_exts_used.add(ext)
+ has_any_image = True
# ---- Legacy SVG embedding mode ----
else:
@@ -403,6 +427,7 @@ def create_pptx_with_native_svg(
if png_success:
slide_has_png = True
has_any_image = True
+ image_exts_used.add('png')
else:
if verbose:
print(f" [{i}/{len(svg_files)}] {svg_path.name} - PNG generation failed, using pure SVG")
@@ -478,6 +503,7 @@ def create_pptx_with_native_svg(
if not poster_path.exists():
poster_path.write_bytes(TRANSPARENT_PNG_BYTES)
has_any_image = True
+ image_exts_used.add('png')
media_rid = _append_relationship(
rels_path,
@@ -535,6 +561,8 @@ def create_pptx_with_native_svg(
except Exception as e:
if verbose:
print(f" [{i}/{len(svg_files)}] {svg_path.name} - Error: {e}")
+ if use_native_shapes:
+ raise
# Update [Content_Types].xml
content_types_path = extract_dir / '[Content_Types].xml'
@@ -545,12 +573,11 @@ def create_pptx_with_native_svg(
if not use_native_shapes:
if 'Extension="svg"' not in content_types:
types_to_add.append(' <Default Extension="svg" ContentType="image/svg+xml"/>')
- if has_any_image and 'Extension="png"' not in content_types:
- types_to_add.append(' <Default Extension="png" ContentType="image/png"/>')
- if use_native_shapes and 'Extension="jpg"' not in content_types:
- types_to_add.append(' <Default Extension="jpg" ContentType="image/jpeg"/>')
- if use_native_shapes and 'Extension="jpeg"' not in content_types:
- types_to_add.append(' <Default Extension="jpeg" ContentType="image/jpeg"/>')
+ for ext in sorted(image_exts_used):
+ if f'Extension="{ext}"' not in content_types:
+ types_to_add.append(
+ f' <Default Extension="{ext}" ContentType="{_content_type_for_extension(ext)}"/>'
+ )
if types_to_add:
content_types = content_types.replace(
@@ -581,12 +608,15 @@ def create_pptx_with_native_svg(
with open(content_types_path, 'w', encoding='utf-8') as f:
f.write(content_types)
- # Repackage PPTX
- with zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED) as zf:
+ # Repackage PPTX to a temporary file first. The public output path is
+ # replaced only after every slide and relationship has succeeded.
+ temp_output_path = temp_dir / 'result.pptx'
+ with zipfile.ZipFile(temp_output_path, 'w', zipfile.ZIP_DEFLATED) as zf:
for file_path in extract_dir.rglob('*'):
if file_path.is_file():
arcname = file_path.relative_to(extract_dir)
zf.write(file_path, arcname)
+ shutil.move(str(temp_output_path), str(output_path))
if verbose:
print()
diff --git a/skills/ppt-master/scripts/template_import/manifest.py b/skills/ppt-master/scripts/template_import/manifest.py
index 4a3259f3..40c4f190 100644
--- a/skills/ppt-master/scripts/template_import/manifest.py
+++ b/skills/ppt-master/scripts/template_import/manifest.py
@@ -66,6 +66,8 @@ class SlideRecord:
text_count: int
shape_count: int
page_type: str
+ svg_file: str
+ flat_svg_file: str
def summarize_part_record(
@@ -77,6 +79,8 @@ def summarize_part_record(
used_by_slides: list[int],
parent_path: str | None = None,
theme_path: str | None = None,
+ svg_file: str | None = None,
+ theme: dict[str, Any] | None = None,
) -> dict[str, Any] | None:
if not part_path:
return None
@@ -86,10 +90,13 @@ def summarize_part_record(
return {
"path": part_path,
"name": PurePosixPath(part_path).name,
+ "svgFile": svg_file,
"parentPath": parent_path,
"themePath": theme_path,
+ "theme": theme,
"backgroundAsset": copied_assets.get(bg_asset, PurePosixPath(bg_asset).name if bg_asset else None),
"imageAssets": [copied_assets.get(target, PurePosixPath(target).name) for target in image_targets],
+ "placeholders": extract_placeholders(root),
"textSamples": extract_text_samples(root),
"textCount": len(root.findall(".//a:t", NS)) if root is not None else 0,
"shapeCount": count_slide_shapes(root),
@@ -151,6 +158,98 @@ def sanitize_filename(value: str) -> str:
return value.strip("._") or "asset"
+def part_svg_filename(role: str, seq: int, part_path: str) -> str:
+ stem = PurePosixPath(part_path).stem
+ safe_stem = re.sub(r"[^A-Za-z0-9_-]+", "_", stem).strip("_") or role
+ return f"{role}_{seq:02d}_{safe_stem}.svg"
+
+
+def slide_svg_filename(index: int) -> str:
+ return f"slide_{index:02d}.svg"
+
+
+def resolve_first_rel(
+ rels: dict[str, dict[str, str]],
+ rel_type: str,
+) -> str | None:
+ for rel in rels.values():
+ if rel["type"] == rel_type:
+ return rel["target"]
+ return None
+
+
+def parse_xfrm_record(sp: ET.Element) -> dict[str, int] | None:
+ xfrm = sp.find("p:spPr/a:xfrm", NS)
+ if xfrm is None:
+ return None
+ off = xfrm.find("a:off", NS)
+ ext = xfrm.find("a:ext", NS)
+ if off is None or ext is None:
+ return None
+ try:
+ x = int(off.attrib.get("x", "0"))
+ y = int(off.attrib.get("y", "0"))
+ w = int(ext.attrib.get("cx", "0"))
+ h = int(ext.attrib.get("cy", "0"))
+ except ValueError:
+ return None
+ return {
+ "x": emu_to_pixels(x),
+ "y": emu_to_pixels(y),
+ "width": emu_to_pixels(w),
+ "height": emu_to_pixels(h),
+ }
+
+
+def extract_placeholders(root: ET.Element | None) -> list[dict[str, Any]]:
+ if root is None:
+ return []
+ placeholders: list[dict[str, Any]] = []
+ for sp in root.findall(".//p:sp", NS):
+ ph = sp.find("p:nvSpPr/p:nvPr/p:ph", NS)
+ if ph is None:
+ continue
+ record: dict[str, Any] = {
+ "type": ph.attrib.get("type"),
+ "idx": ph.attrib.get("idx"),
+ "size": ph.attrib.get("sz"),
+ "orient": ph.attrib.get("orient"),
+ "geometry": parse_xfrm_record(sp),
+ "textSamples": extract_text_samples(sp, limit=2),
+ }
+ style = extract_placeholder_text_style(sp)
+ if style:
+ record["textStyle"] = style
+ placeholders.append(record)
+ return placeholders
+
+
+def extract_placeholder_text_style(sp: ET.Element) -> dict[str, Any]:
+ style: dict[str, Any] = {}
+ rpr = sp.find(".//a:rPr", NS) or sp.find(".//a:endParaRPr", NS)
+ if rpr is None:
+ return style
+ if rpr.attrib.get("sz"):
+ try:
+ style["fontSizePx"] = round(int(rpr.attrib["sz"]) / 75, 2)
+ except ValueError:
+ pass
+ if rpr.attrib.get("b") == "1":
+ style["bold"] = True
+ if rpr.attrib.get("i") == "1":
+ style["italic"] = True
+ latin = rpr.find("a:latin", NS)
+ ea = rpr.find("a:ea", NS)
+ if latin is not None and latin.attrib.get("typeface"):
+ style["latinFont"] = latin.attrib["typeface"]
+ if ea is not None and ea.attrib.get("typeface"):
+ style["eastAsiaFont"] = ea.attrib["typeface"]
+ color = rpr.find("a:solidFill/a:srgbClr", NS)
+ if color is not None and color.attrib.get("val"):
+ style["fill"] = f"#{color.attrib['val']}"
+ return style
+
+
def extract_text_samples(root: ET.Element | None, limit: int = 6) -> list[str]:
if root is None:
return []
@@ -366,6 +465,36 @@ def build_manifest(pptx_path: Path, output_dir: Path) -> dict[str, Any]:
if rel and rel["type"] == SLIDE_REL:
slide_parts.append(rel["target"])
+ master_parts: list[str] = []
+ for master_id in presentation_root.findall("p:sldMasterIdLst/p:sldMasterId", NS):
+ rel_id = master_id.attrib.get(f"{{{NS['r']}}}id")
+ rel = presentation_rels.get(rel_id or "")
+ if rel and rel["type"] == MASTER_REL and rel["target"] not in master_parts:
+ master_parts.append(rel["target"])
+
+ master_roots: dict[str, ET.Element | None] = {}
+ master_rels_map: dict[str, dict[str, dict[str, str]]] = {}
+ master_theme_path: dict[str, str | None] = {}
+ layout_parts: list[str] = []
+ layout_parent: dict[str, str | None] = {}
+ for master_path in master_parts:
+ master_root = load_xml_from_zip(zf, master_path)
+ master_rels = parse_relationships(zf, master_path)
+ master_roots[master_path] = master_root
+ master_rels_map[master_path] = master_rels
+ master_theme_path[master_path] = resolve_first_rel(master_rels, THEME_REL)
+ if master_root is None:
+ continue
+ for layout_id in master_root.findall("p:sldLayoutIdLst/p:sldLayoutId", NS):
+ rel_id = layout_id.attrib.get(f"{{{NS['r']}}}id")
+ rel = master_rels.get(rel_id or "")
+ if not rel or rel["type"] != LAYOUT_REL:
+ continue
+ layout_path = rel["target"]
+ if layout_path not in layout_parent:
+ layout_parent[layout_path] = master_path
+ layout_parts.append(layout_path)
+
asset_dir = output_dir / "assets"
if asset_dir.exists():
shutil.rmtree(asset_dir)
@@ -457,6 +586,9 @@ def build_manifest(pptx_path: Path, output_dir: Path) -> dict[str, Any]:
asset_usage[asset_name] += 1
if layout_path:
+ if layout_path not in layout_parent:
+ layout_parent[layout_path] = master_path
+ layout_parts.append(layout_path)
layout_usage[layout_path].append(index)
if layout_path not in layout_cache:
layout_cache[layout_path] = {
@@ -465,6 +597,11 @@ def build_manifest(pptx_path: Path, output_dir: Path) -> dict[str, Any]:
"master_path": master_path,
}
if master_path:
+ if master_path not in master_parts:
+ master_parts.append(master_path)
+ master_roots[master_path] = master_root
+ master_rels_map[master_path] = master_rels
+ master_theme_path[master_path] = theme_path
master_usage[master_path].append(index)
if master_path not in master_cache:
master_cache[master_path] = {
@@ -487,10 +624,31 @@ def build_manifest(pptx_path: Path, output_dir: Path) -> dict[str, Any]:
text_count=len(texts),
shape_count=shape_count,
page_type=page_type,
+ svg_file=slide_svg_filename(index),
+ flat_svg_file=slide_svg_filename(index),
)
)
- common_assets = choose_common_assets(asset_usage)
+ for layout_path in layout_parts:
+ if layout_path in layout_cache:
+ continue
+ layout_root = load_xml_from_zip(zf, layout_path)
+ layout_rels = parse_relationships(zf, layout_path)
+ layout_cache[layout_path] = {
+ "root": layout_root,
+ "rels": layout_rels,
+ "master_path": layout_parent.get(layout_path),
+ }
+
+ for master_path in master_parts:
+ if master_path in master_cache:
+ continue
+ master_cache[master_path] = {
+ "root": master_roots.get(master_path),
+ "rels": master_rels_map.get(master_path, {}),
+ "theme_path": master_theme_path.get(master_path),
+ }
+
page_type_map: dict[str, list[int]] = defaultdict(list)
for slide in slide_records:
page_type_map[slide.page_type].append(slide.index)
@@ -503,8 +661,10 @@ def build_manifest(pptx_path: Path, output_dir: Path) -> dict[str, Any]:
copied_assets=copied_assets,
used_by_slides=layout_usage[layout_path],
parent_path=layout_cache[layout_path]["master_path"],
+ svg_file=part_svg_filename("layout", seq, layout_path),
)
- for layout_path in sorted(layout_cache.keys())
+ for seq, layout_path in enumerate(layout_parts, start=1)
+ if layout_path in layout_cache
]
master_records = [
summarize_part_record(
@@ -514,12 +674,41 @@ def build_manifest(pptx_path: Path, output_dir: Path) -> dict[str, Any]:
copied_assets=copied_assets,
used_by_slides=master_usage[master_path],
theme_path=master_cache[master_path]["theme_path"],
+ svg_file=part_svg_filename("master", seq, master_path),
+ theme=parse_theme(load_xml_from_zip(zf, master_cache[master_path]["theme_path"]))
+ if master_cache[master_path]["theme_path"] else {"colors": {}, "fonts": {}},
)
- for master_path in sorted(master_cache.keys())
+ for seq, master_path in enumerate(master_parts, start=1)
+ if master_path in master_cache
]
layouts_top = [item for item in layout_records if item]
masters_top = [item for item in master_records if item]
+ layout_by_path = {item["path"]: item for item in layouts_top}
+ master_by_path = {item["path"]: item for item in masters_top}
+ asset_usage = Counter()
+ for slide in slide_records:
+ per_slide_assets: set[str] = set(slide.image_assets)
+ if slide.background_asset:
+ per_slide_assets.add(slide.background_asset)
+ layout_record = layout_by_path.get(slide.layout_path or "")
+ if layout_record:
+ if layout_record.get("backgroundAsset"):
+ per_slide_assets.add(layout_record["backgroundAsset"])
+ per_slide_assets.update(layout_record.get("imageAssets", []))
+ master_record = master_by_path.get(slide.master_path or "")
+ if master_record:
+ if master_record.get("backgroundAsset"):
+ per_slide_assets.add(master_record["backgroundAsset"])
+ per_slide_assets.update(master_record.get("imageAssets", []))
+ for asset in per_slide_assets:
+ if asset:
+ asset_usage[asset] += 1
+
+ common_assets = choose_common_assets(asset_usage)
+ if not theme_summary["colors"] and not theme_summary["fonts"] and masters_top:
+ theme_summary = masters_top[0].get("theme") or {"colors": {}, "fonts": {}}
+
manifest = {
"source": {
"pptx": str(pptx_path),
@@ -531,6 +720,7 @@ def build_manifest(pptx_path: Path, output_dir: Path) -> dict[str, Any]:
"exportDir": "assets",
"commonAssets": common_assets,
"allAssets": sorted(copied_assets.values()),
+ "assetMap": copied_assets,
},
"pageTypeCandidates": dict(sorted(page_type_map.items())),
"layouts": layouts_top,
@@ -539,6 +729,8 @@ def build_manifest(pptx_path: Path, output_dir: Path) -> dict[str, Any]:
{
"index": slide.index,
"name": slide.name,
+ "svgFile": slide.svg_file,
+ "flatSvgFile": slide.flat_svg_file,
"slidePath": slide.slide_path,
"layoutPath": slide.layout_path,
"masterPath": slide.master_path,