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

feat(formula): add a native-shape mc:Fallback for non-PowerPoint clients

hugohe3dc7eab3fbf25
diff --git a/skills/ppt-master/scripts/pptx_ooxml/ooxml.py b/skills/ppt-master/scripts/pptx_ooxml/ooxml.py
index 60790f25..d8f60b23 100644
--- a/skills/ppt-master/scripts/pptx_ooxml/ooxml.py
+++ b/skills/ppt-master/scripts/pptx_ooxml/ooxml.py
@@ -254,9 +254,17 @@ def _container_geometry(
def _text_containers(slide_root: ET.Element) -> list[ET.Element]:
+ # mc:Fallback repeats its Choice for other clients; it is not slide content.
+ fallback_nodes = {
+ node
+ for fallback in slide_root.iter(f"{{{MC_NS}}}Fallback")
+ for node in fallback.iter()
+ }
containers: list[ET.Element] = []
for tag in ("p:sp", "p:graphicFrame"):
for element in slide_root.findall(f".//{tag}", NS):
+ if element in fallback_nodes:
+ continue
if element.find(".//p:txBody", NS) is not None or element.findall(".//a:t", NS):
containers.append(element)
return containers
diff --git a/skills/ppt-master/scripts/source_to_md/ppt_to_md.py b/skills/ppt-master/scripts/source_to_md/ppt_to_md.py
index 5db41127..a880e567 100644
--- a/skills/ppt-master/scripts/source_to_md/ppt_to_md.py
+++ b/skills/ppt-master/scripts/source_to_md/ppt_to_md.py
@@ -73,6 +73,7 @@ EMU_PER_INCH = 914400
DRAWINGML_NS = "http://schemas.openxmlformats.org/drawingml/2006/main"
PRESENTATIONML_NS = "http://schemas.openxmlformats.org/presentationml/2006/main"
RELATIONSHIP_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+MARKUP_COMPATIBILITY_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006"
CHARTEX_URI = "http://schemas.microsoft.com/office/drawing/2014/chartex"
OFFICE_VECTOR_EXTENSIONS = {"emf", "wmf"}
IMAGE_EXT_BY_CONTENT_TYPE = {
@@ -186,6 +187,34 @@ def _safe_position(shape: object, attr: str) -> int:
return 0
+def _expose_math_choice_shapes(slide: object) -> None:
+ """Unwrap a14 Office Math Choice shapes so ``slide.shapes`` sees them.
+
+ python-pptx skips every ``mc:AlternateContent`` in the shape tree, which
+ hides formula text boxes and the ordinary text around their math. Only the
+ in-memory read view changes; the source file is never written.
+ """
+ alternate_tag = f"{{{MARKUP_COMPATIBILITY_NS}}}AlternateContent"
+ choice_tag = f"{{{MARKUP_COMPATIBILITY_NS}}}Choice"
+ shape_tags = {f"{{{PRESENTATIONML_NS}}}sp", f"{{{PRESENTATIONML_NS}}}grpSp"}
+ for wrapper in list(slide.element.iter(alternate_tag)):
+ choice = wrapper.find(choice_tag)
+ parent = wrapper.getparent()
+ if (
+ choice is None
+ or parent is None
+ or "a14" not in (choice.get("Requires") or "").split()
+ ):
+ continue
+ shapes = list(choice)
+ if not shapes or any(shape.tag not in shape_tags for shape in shapes):
+ continue
+ index = parent.index(wrapper)
+ parent.remove(wrapper)
+ for offset, shape in enumerate(shapes):
+ parent.insert(index + offset, shape)
+
+
def iter_leaf_shapes(shapes: object) -> list[LeafShape]:
"""Return a flattened, reading-order list of shapes."""
items: list[LeafShape] = []
@@ -1278,6 +1307,7 @@ def convert_presentation_to_markdown(
}
emitted_diagram_ids: set[str] = set()
emitted_chart_relationship_ids: set[str] = set()
+ _expose_math_choice_shapes(slide)
for item in iter_leaf_shapes(slide.shapes):
shape = item.shape
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 cfe67305..0b836d3b 100644
--- a/skills/ppt-master/scripts/svg_to_pptx/drawingml/converter.py
+++ b/skills/ppt-master/scripts/svg_to_pptx/drawingml/converter.py
@@ -127,6 +127,8 @@ from ..native_objects import (
require_fresh_native_fallback,
snapshot_native_fallback_freshness,
)
+from ..native_objects.formula import formula_fallback_xml
+from ..native_objects.inline_formula import wrap_inline_formula_shape
from ..native_objects.marker_status import native_marker_status_errors
from ..semantic_markers import is_static_page_frame
@@ -724,6 +726,60 @@ def _append_shape_text(
)
+_A14_NS = 'http://schemas.microsoft.com/office/drawing/2010/main'
+_A14_MATH_TAG = f'{{{_A14_NS}}}m'
+# Generated txBody fragments rely on the slide's prefixes; bind them to parse.
+_TXBODY_PREFIXES = (
+ 'xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main" '
+ f'xmlns:a="{DRAWINGML_NS}" xmlns:a14="{_A14_NS}" '
+ 'xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math"'
+)
+
+
+def _txbody_has_office_math(txbody_xml: str) -> bool:
+ try:
+ body = re.sub(r'^\s*<\?xml[^>]*\?>', '', txbody_xml)
+ root = ET.fromstring(f'<root {_TXBODY_PREFIXES}>{body}</root>')
+ except ET.ParseError:
+ return False
+ return any(node.tag == _A14_MATH_TAG for node in root.iter())
+
+
+def _with_office_math_fallback(
+ elem: ET.Element,
+ restored: ShapeResult,
+ geometry: ShapeResult,
+ ctx: ConvertContext,
+) -> ShapeResult:
+ """Give a shape's Office Math text its visible SVG text as MCE Fallback."""
+ # The copy is a plain picture of the shape: fresh id, no placeholder role.
+ carrier_xml = re.sub(
+ r'<p:cNvPr id="\d+"',
+ f'<p:cNvPr id="{ctx.next_id()}"',
+ geometry.xml,
+ count=1,
+ )
+ carrier_xml = re.sub(r'<p:ph\b[^>]*/>', '', carrier_xml)
+ results = [ShapeResult(xml=carrier_xml, bounds_emu=geometry.bounds_emu)]
+ for child in elem:
+ if (
+ child.get('data-pptx-part') is None
+ and child.tag.replace(f'{{{SVG_NS}}}', '') in {'text', 'g'}
+ ):
+ result = convert_element(child, ctx)
+ if result:
+ results.append(result)
+ fallback_xml = formula_fallback_xml(
+ results,
+ ctx,
+ _xml_escape(shape_display_name(elem, 'Formula')),
+ )
+ return ShapeResult(
+ xml=wrap_inline_formula_shape(restored.xml, fallback_xml),
+ bounds_emu=restored.bounds_emu,
+ )
+
+
def _make_semantic_geometry_carrier_visible(element: ET.Element) -> None:
"""Remove authoring-only hiding from a semantic geometry carrier clone."""
for name in ('visibility', 'display', 'pointer-events'):
@@ -847,7 +903,12 @@ def _convert_semantic_shape(
'Semantic shape geometry carrier produced no native shape'
)
text_body = _semantic_shape_text_body(shape, ctx)
- return _append_shape_text(geometry, text_body) if text_body else geometry
+ if not text_body:
+ return geometry
+ restored = _append_shape_text(geometry, text_body)
+ if _txbody_has_office_math(text_body):
+ return _with_office_math_fallback(shape, restored, geometry, ctx)
+ return restored
def _restore_placeholder_sp_pr(
@@ -1313,6 +1374,11 @@ def convert_g(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
native_text,
)
restored = _restore_placeholder_sp_pr(restored, elem)
+ if _txbody_has_office_math(native_text):
+ restored = _with_office_math_fallback(
+ elem, restored, geometry_result, geometry_ctx,
+ )
+ ctx.sync_from_child(geometry_ctx)
if should_animate_group and elem_id:
shape_match = re.search(r'<p:cNvPr id="(\d+)"', restored.xml)
if shape_match:
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 a138db30..3ee9f0ac 100644
--- a/skills/ppt-master/scripts/svg_to_pptx/drawingml/elements.py
+++ b/skills/ppt-master/scripts/svg_to_pptx/drawingml/elements.py
@@ -3085,6 +3085,15 @@ def _text_axis_transform(ctx: ConvertContext) -> tuple[bool, bool, bool]:
return True, a < 0, d < 0
+def _inline_formula_preview_run(run: dict[str, Any]) -> dict[str, Any]:
+ """Return an inline formula run as its ordinary SVG preview-text run."""
+ if run.get(_INLINE_FORMULA_KEY) is None:
+ return run
+ preview = dict(run)
+ del preview[_INLINE_FORMULA_KEY]
+ return preview
+
+
def _build_run_xml(
run: dict[str, Any],
default_fonts: dict[str, str],
@@ -3590,47 +3599,61 @@ def convert_text(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
shape_id = _claim_element_shape_id(elem, ctx)
rot_attr = f' rot="{text_rot}"' if text_rot else ''
- if paragraph_runs is not None:
- # SVG dy(px) -> hundredths-of-a-point: dy_pt = dy_px * 0.75, then x100.
- line_spc_val = round(line_height_px * FONT_PX_TO_HUNDREDTHS_PT)
- ln_spc_xml = f'<a:lnSpc><a:spcPts val="{line_spc_val}"/></a:lnSpc>'
- paragraph_xml_chunks = []
- for line, extra_px, bullet in zip(paragraph_runs, paragraph_space_before, paragraph_bullets):
- spc_bef_xml = ''
- if extra_px > 0:
- spc_bef_val = round(extra_px * FONT_PX_TO_HUNDREDTHS_PT)
- spc_bef_xml = f'<a:spcBef><a:spcPts val="{spc_bef_val}"/></a:spcBef>'
- runs_inner = '\n'.join(_build_run_xml(r, fonts, ctx, text_effect_xml) for r in line)
- first_text_run = next(
- (run for run in line if not run.get('_line_break')),
- None,
- )
- effective_line_spacing = (
- ''
- if any(run.get(_INLINE_FORMULA_KEY) is not None for run in line)
- else ln_spc_xml
- )
- p_pr_xml = _paragraph_pr_xml(
- algn=algn,
- font_size=(
- float(first_text_run.get('font_size', font_size))
- if first_text_run is not None
- else font_size
- ),
- body_xml=f'{effective_line_spacing}{spc_bef_xml}',
- bullet=bullet,
- ctx=ctx,
- rtl=text_uses_rtl(
- ''.join(str(run.get('text', '')) for run in line),
- ctx.primary_language,
- ),
- )
- paragraph_xml_chunks.append(
- f'<a:p>\n{p_pr_xml}\n{runs_inner}\n</a:p>'
+ def _paragraphs_xml(formula_previews: bool) -> str:
+ # The MCE Fallback copy writes each inline formula as its SVG preview
+ # text so a reader without a14 math still shows the formula.
+ def _runs_xml(line_runs: list[dict[str, Any]]) -> str:
+ return '\n'.join(
+ _build_run_xml(
+ _inline_formula_preview_run(r) if formula_previews else r,
+ fonts,
+ ctx,
+ text_effect_xml,
+ )
+ for r in line_runs
)
- paragraphs_xml = '\n'.join(paragraph_xml_chunks)
- else:
- runs_xml = '\n'.join(_build_run_xml(r, fonts, ctx, text_effect_xml) for r in runs)
+
+ if paragraph_runs is not None:
+ # SVG dy(px) -> hundredths-of-a-point: dy_pt = dy_px * 0.75, then x100.
+ line_spc_val = round(line_height_px * FONT_PX_TO_HUNDREDTHS_PT)
+ ln_spc_xml = f'<a:lnSpc><a:spcPts val="{line_spc_val}"/></a:lnSpc>'
+ paragraph_xml_chunks = []
+ for line, extra_px, bullet in zip(paragraph_runs, paragraph_space_before, paragraph_bullets):
+ spc_bef_xml = ''
+ if extra_px > 0:
+ spc_bef_val = round(extra_px * FONT_PX_TO_HUNDREDTHS_PT)
+ spc_bef_xml = f'<a:spcBef><a:spcPts val="{spc_bef_val}"/></a:spcBef>'
+ runs_inner = _runs_xml(line)
+ first_text_run = next(
+ (run for run in line if not run.get('_line_break')),
+ None,
+ )
+ effective_line_spacing = (
+ ''
+ if any(run.get(_INLINE_FORMULA_KEY) is not None for run in line)
+ else ln_spc_xml
+ )
+ p_pr_xml = _paragraph_pr_xml(
+ algn=algn,
+ font_size=(
+ float(first_text_run.get('font_size', font_size))
+ if first_text_run is not None
+ else font_size
+ ),
+ body_xml=f'{effective_line_spacing}{spc_bef_xml}',
+ bullet=bullet,
+ ctx=ctx,
+ rtl=text_uses_rtl(
+ ''.join(str(run.get('text', '')) for run in line),
+ ctx.primary_language,
+ ),
+ )
+ paragraph_xml_chunks.append(
+ f'<a:p>\n{p_pr_xml}\n{runs_inner}\n</a:p>'
+ )
+ return '\n'.join(paragraph_xml_chunks)
+
+ runs_xml = _runs_xml(runs)
p_pr_xml = _paragraph_pr_xml(
algn=algn,
font_size=float(runs[0].get('font_size', font_size)) if runs else font_size,
@@ -3638,7 +3661,9 @@ def convert_text(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
ctx=ctx,
rtl=text_uses_rtl(full_text, ctx.primary_language),
)
- paragraphs_xml = f'<a:p>\n{p_pr_xml}\n{runs_xml}\n</a:p>'
+ return f'<a:p>\n{p_pr_xml}\n{runs_xml}\n</a:p>'
+
+ paragraphs_xml = _paragraphs_xml(False)
off_x = px_to_emu(box_x)
off_y = px_to_emu(box_y)
@@ -3702,9 +3727,10 @@ def convert_text(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
'anchor="t" anchorCtr="0">\n<a:spAutoFit/>\n</a:bodyPr>'
)
- shape_xml = f'''<p:sp>
+ def _shape_xml(sp_id: int, sp_paragraphs_xml: str) -> str:
+ return f'''<p:sp>
<p:nvSpPr>
-<p:cNvPr id="{shape_id}" name="{_xml_escape(shape_display_name(elem, f'TextBox {shape_id}'))}"/>
+<p:cNvPr id="{sp_id}" name="{_xml_escape(shape_display_name(elem, f'TextBox {sp_id}'))}"/>
<p:cNvSpPr txBox="1"/><p:nvPr/>
</p:nvSpPr>
<p:spPr>
@@ -3718,12 +3744,17 @@ def convert_text(elem: ET.Element, ctx: ConvertContext) -> ShapeResult | None:
<p:txBody>
{body_pr_xml}
<a:lstStyle/>
-{paragraphs_xml}
+{sp_paragraphs_xml}
</p:txBody>
</p:sp>'''
+
+ shape_xml = _shape_xml(shape_id, paragraphs_xml)
if any(run.get(_INLINE_FORMULA_KEY) is not None for run in runs):
from ..native_objects.inline_formula import wrap_inline_formula_shape
- shape_xml = wrap_inline_formula_shape(shape_xml)
+ shape_xml = wrap_inline_formula_shape(
+ shape_xml,
+ _shape_xml(ctx.next_id(), _paragraphs_xml(True)),
+ )
return ShapeResult(
xml=shape_xml,
bounds_emu=(off_x, off_y, off_x + ext_cx, off_y + ext_cy),
diff --git a/skills/ppt-master/scripts/svg_to_pptx/native_objects/formula.py b/skills/ppt-master/scripts/svg_to_pptx/native_objects/formula.py
index 13b6b0dd..de98ac49 100644
--- a/skills/ppt-master/scripts/svg_to_pptx/native_objects/formula.py
+++ b/skills/ppt-master/scripts/svg_to_pptx/native_objects/formula.py
@@ -196,13 +196,59 @@ def _styled_omml(spec: FormulaSpec) -> str:
return serialize_styled_formula_omml(root)
+def formula_fallback_xml(
+ results: list[ShapeResult],
+ ctx: ConvertContext,
+ name: str,
+) -> str:
+ """Join converted preview shapes into one MCE Fallback shape (or none)."""
+ if not results:
+ return ""
+ if len(results) == 1:
+ return results[0].xml
+ bounds = [result.bounds_emu for result in results if result.bounds_emu]
+ if not bounds:
+ return "\n".join(result.xml for result in results)
+ min_x = min(box[0] for box in bounds)
+ min_y = min(box[1] for box in bounds)
+ ext_cx = max(max(box[2] for box in bounds) - min_x, 1)
+ ext_cy = max(max(box[3] for box in bounds) - min_y, 1)
+ shapes_xml = "\n".join(result.xml for result in results)
+ return f'''<p:grpSp>
+<p:nvGrpSpPr>
+<p:cNvPr id="{ctx.next_id()}" name="{name}"/>
+<p:cNvGrpSpPr/>
+<p:nvPr/>
+</p:nvGrpSpPr>
+<p:grpSpPr>
+<a:xfrm><a:off x="{min_x}" y="{min_y}"/><a:ext cx="{ext_cx}" cy="{ext_cy}"/>
+<a:chOff x="{min_x}" y="{min_y}"/><a:chExt cx="{ext_cx}" cy="{ext_cy}"/></a:xfrm>
+</p:grpSpPr>
+{shapes_xml}
+</p:grpSp>'''
+
+
+def _preview_fallback_xml(elem: ET.Element, ctx: ConvertContext, name: str) -> str:
+ """Convert the marker's SVG preview into native shapes for the MCE Fallback."""
+ # Deferred import: the drawingml converter imports this package.
+ from ..drawingml.converter import convert_element
+
+ results = [
+ result
+ for child in elem
+ if child.tag.rsplit("}", 1)[-1] != "metadata"
+ and (result := convert_element(child, ctx)) is not None
+ ]
+ return formula_fallback_xml(results, ctx, name)
+
+
def build_native_formula(
elem: ET.Element,
ctx: ConvertContext,
payload: dict[str, Any],
spec: FormulaSpec | None = None,
) -> ShapeResult:
- """Build one Choice-only editable formula with no image fallback."""
+ """Build one editable formula whose MCE Fallback is its SVG preview."""
formula_spec = spec or validate_formula_payload(payload, ctx=ctx)
off_x, off_y, ext_cx, ext_cy = _bounds(elem, payload, ctx)
shape_id = ctx.next_id()
@@ -210,6 +256,8 @@ def build_native_formula(
str(payload.get("name") or elem.get("id") or f"Formula {shape_id}")
)
omml = _styled_omml(formula_spec)
+ fallback_xml = _preview_fallback_xml(elem, ctx, name)
+ fallback = f"\n<mc:Fallback>\n{fallback_xml}\n</mc:Fallback>" if fallback_xml else ""
xml = f'''<mc:AlternateContent xmlns:mc="{MC_NS}">
<mc:Choice xmlns:a14="{A14_NS}" Requires="a14">
@@ -235,7 +283,7 @@ def build_native_formula(
</a:p>
</p:txBody>
</p:sp>
-</mc:Choice>
+</mc:Choice>{fallback}
</mc:AlternateContent>'''
return ShapeResult(
xml=xml,
diff --git a/skills/ppt-master/scripts/svg_to_pptx/native_objects/inline_formula.py b/skills/ppt-master/scripts/svg_to_pptx/native_objects/inline_formula.py
index d429b951..2ae47aba 100644
--- a/skills/ppt-master/scripts/svg_to_pptx/native_objects/inline_formula.py
+++ b/skills/ppt-master/scripts/svg_to_pptx/native_objects/inline_formula.py
@@ -292,13 +292,14 @@ def build_inline_formula_xml(latex: str, run_properties_xml: str) -> str:
return f"<a14:m>{styled}</a14:m>"
-def wrap_inline_formula_shape(shape_xml: str) -> str:
- """Wrap a text shape containing ``a14:m`` in its required MCE Choice."""
+def wrap_inline_formula_shape(shape_xml: str, fallback_xml: str) -> str:
+ """Wrap an ``a14:m`` text shape in its MCE Choice plus preview-text Fallback."""
return (
f'<mc:AlternateContent xmlns:mc="{MC_NS}">'
f'<mc:Choice xmlns:a14="{A14_NS}" Requires="a14">'
f"{shape_xml}"
"</mc:Choice>"
+ f"<mc:Fallback>{fallback_xml}</mc:Fallback>"
"</mc:AlternateContent>"
)
diff --git a/skills/ppt-master/scripts/tests/test_formula_fallback.py b/skills/ppt-master/scripts/tests/test_formula_fallback.py
new file mode 100644
index 00000000..8eb66b38
--- /dev/null
+++ b/skills/ppt-master/scripts/tests/test_formula_fallback.py
@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""
+PPT Master - Native Formula MCE Fallback Regression Tests
+
+Check that block and inline formulas carry their SVG preview as native shapes
+in mc:Fallback while PowerPoint keeps reading the editable a14 Choice.
+
+Usage:
+ python3 -m unittest tests.test_formula_fallback
+
+Examples:
+ Run the module from the scripts directory.
+
+Dependencies:
+ Standard library and the local SVG-to-PPTX / PPTX-to-SVG converters.
+"""
+
+from __future__ import annotations
+
+import base64
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+
+SCRIPTS_DIR = Path(__file__).resolve().parents[1]
+if str(SCRIPTS_DIR) not in sys.path:
+ sys.path.insert(0, str(SCRIPTS_DIR))
+
+from pptx_ooxml.ooxml import _text_containers # noqa: E402
+from pptx_shapes.semantic_hash import svg_text_fingerprint # noqa: E402
+from pptx_to_svg.shape_walker import _resolve_alternate_content # noqa: E402
+from svg_to_pptx.drawingml.converter import convert_svg_to_slide_shapes # noqa: E402
+
+
+NS = {
+ 'a': 'http://schemas.openxmlformats.org/drawingml/2006/main',
+ 'a14': 'http://schemas.microsoft.com/office/drawing/2010/main',
+ 'm': 'http://schemas.openxmlformats.org/officeDocument/2006/math',
+ 'mc': 'http://schemas.openxmlformats.org/markup-compatibility/2006',
+ 'p': 'http://schemas.openxmlformats.org/presentationml/2006/main',
+}
+
+BLOCK_FORMULA = (
+ '<g id="dscr" data-pptx-replace-with="formula" '
+ 'data-pptx-x="200" data-pptx-y="200" data-pptx-width="600" '
+ 'data-pptx-height="160" data-pptx-bounds="200 200 600 160">'
+ '<metadata type="application/json"><![CDATA['
+ '{"latex":"DSCR=\\\\frac{EBITDA}{PD}","display":"block",'
+ '"font_size":40,"color":"#173B57","align":"center"}'
+ ']]></metadata>'
+ '{preview}'
+ '</g>'
+)
+
+
+def _block_formula(preview: str) -> str:
+ return BLOCK_FORMULA.replace('{preview}', preview)
+
+
+def _preserved_formula_shape(extra_attributes: str = '') -> str:
+ """An imported shape whose unchanged source txBody holds Office Math."""
+ txbody = (
+ f'<p:txBody xmlns:p="{NS["p"]}" xmlns:a="{NS["a"]}" '
+ f'xmlns:a14="{NS["a14"]}" xmlns:m="{NS["m"]}">'
+ '<a:bodyPr/><a:lstStyle/><a:p><a14:m><m:oMathPara><m:oMath>'
+ '<m:f><m:num><m:r><m:t>a</m:t></m:r></m:num>'
+ '<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f>'
+ '</m:oMath></m:oMathPara></a14:m></a:p></p:txBody>'
+ )
+ shape = (
+ '<g xmlns="http://www.w3.org/2000/svg" id="shape-13" '
+ 'data-pptx-object="shape" data-pptx-frame="64 200 896 104" '
+ f'data-pptx-prst="rect" data-pptx-semantic-object="shape"{extra_attributes}>'
+ '<path d="M 64 200 L 960 200 L 960 304 L 64 304 Z" fill="#F5F5F5" '
+ 'stroke="none" data-pptx-part="geometry"/>'
+ '<metadata data-pptx-part="txbody" data-pptx-encoding="base64" '
+ 'data-pptx-text-sha256="{sha}">'
+ f'{base64.b64encode(txbody.encode("utf-8")).decode("ascii")}'
+ '</metadata>'
+ '<text x="512" y="262" text-anchor="middle" font-size="28" '
+ 'fill="#123B63">a/b</text>'
+ '</g>'
+ )
+ sha = svg_text_fingerprint(ET.fromstring(shape.replace('{sha}', '')))
+ return shape.replace(' xmlns="http://www.w3.org/2000/svg"', '').replace(
+ '{sha}', sha,
+ )
+
+
+class FormulaFallbackTests(unittest.TestCase):
+ def setUp(self) -> None:
+ temporary = tempfile.TemporaryDirectory()
+ self.addCleanup(temporary.cleanup)
+ self.root = Path(temporary.name)
+ self.svg_path = self.root / '01_formula.svg'
+
+ def _export(self, body: str) -> ET.Element:
+ self.svg_path.write_text(
+ '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1280 720">'
+ f'{body}</svg>',
+ encoding='utf-8',
+ )
+ xml, *_rest = convert_svg_to_slide_shapes(
+ self.svg_path, resource_root=self.root,
+ )
+ return ET.fromstring(xml)
+
+ def _alternate_content(self, slide: ET.Element) -> ET.Element:
+ wrappers = slide.findall('.//mc:AlternateContent', NS)
+ self.assertEqual(len(wrappers), 1)
+ return wrappers[0]
+
+ def _assert_unique_shape_ids(self, slide: ET.Element) -> None:
+ ids = [node.get('id') for node in slide.iter(f"{{{NS['p']}}}cNvPr")]
+ self.assertEqual(len(ids), len(set(ids)))
+
+ def test_block_formula_fallback_is_preview_text(self) -> None:
+ slide = self._export(_block_formula(
+ (
+ '<text x="500" y="290" text-anchor="middle" font-size="40" '
+ 'fill="#173B57">DSCR = EBITDA / PD</text>'
+ ),
+ ))
+ wrapper = self._alternate_content(slide)
+ choice = wrapper.find('mc:Choice', NS)
+ fallback = wrapper.find('mc:Fallback', NS)
+ self.assertEqual(choice.get('Requires'), 'a14')
+ self.assertIsNotNone(choice.find('.//a14:m/m:oMathPara', NS))
+ self.assertIsNotNone(fallback)
+ self.assertIsNone(fallback.find('.//a14:m', NS))
+ fallback_text = ''.join(
+ node.text or '' for node in fallback.iter(f"{{{NS['a']}}}t")
+ )
+ self.assertEqual(fallback_text, 'DSCR = EBITDA / PD')
+ self._assert_unique_shape_ids(slide)
+
+ def test_multi_part_block_preview_becomes_one_group(self) -> None:
+ slide = self._export(_block_formula(
+ (
+ '<text x="300" y="290" font-size="40" fill="#173B57">DSCR =</text>'
+ '<text x="560" y="260" text-anchor="middle" font-size="32" '
+ 'fill="#173B57">EBITDA</text>'
+ '<line x1="480" y1="275" x2="640" y2="275" stroke="#173B57" '
+ 'stroke-width="2"/>'
+ '<text x="560" y="320" text-anchor="middle" font-size="32" '
+ 'fill="#173B57">PD</text>'
+ ),
+ ))
+ fallback = self._alternate_content(slide).find('mc:Fallback', NS)
+ children = list(fallback)
+ self.assertEqual(len(children), 1)
+ self.assertEqual(children[0].tag, f"{{{NS['p']}}}grpSp")
+ self.assertEqual(len(children[0].findall('p:sp', NS)), 4)
+ self._assert_unique_shape_ids(slide)
+
+ def test_inline_formula_fallback_keeps_text_box_with_preview_run(self) -> None:
+ slide = self._export(
+ '<text x="100" y="200" font-size="40" font-family="Microsoft YaHei">'
+ 'ratio <tspan data-pptx-inline-formula="\\frac{a_i}{b_i}">aᵢ/bᵢ</tspan>'
+ ' holds</text>'
+ )
+ wrapper = self._alternate_content(slide)
+ choice_shape = wrapper.find('mc:Choice/p:sp', NS)
+ fallback_shape = wrapper.find('mc:Fallback/p:sp', NS)
+ self.assertIsNotNone(choice_shape.find('.//a14:m/m:oMath', NS))
+ self.assertIsNotNone(fallback_shape)
+ self.assertIsNone(fallback_shape.find('.//a14:m', NS))
+ fallback_text = ''.join(
+ node.text or '' for node in fallback_shape.iter(f"{{{NS['a']}}}t")
+ )
+ self.assertEqual(fallback_text, 'ratio aᵢ/bᵢ holds')
+ self.assertEqual(
+ choice_shape.find('p:spPr/a:xfrm', NS).find('a:off', NS).attrib,
+ fallback_shape.find('p:spPr/a:xfrm', NS).find('a:off', NS).attrib,
+ )
+ self._assert_unique_shape_ids(slide)
+
+ def test_import_selects_choice_and_ignores_fallback(self) -> None:
+ slide = self._export(_block_formula(
+ (
+ '<text x="500" y="290" text-anchor="middle" font-size="40" '
+ 'fill="#173B57">DSCR = EBITDA / PD</text>'
+ ),
+ ))
+ selected = _resolve_alternate_content(self._alternate_content(slide))
+ self.assertIsNotNone(selected)
+ self.assertIsNotNone(selected.find('.//a14:m', NS))
+ self.assertNotIn(
+ 'EBITDA / PD',
+ ''.join(node.text or '' for node in selected.iter(f"{{{NS['a']}}}t")),
+ )
+
+ def test_text_readback_ignores_fallback_copy(self) -> None:
+ slide = self._export(
+ '<text x="100" y="200" font-size="40" font-family="Microsoft YaHei">'
+ 'ratio <tspan data-pptx-inline-formula="x">x</tspan> holds</text>'
+ )
+ containers = _text_containers(slide)
+ self.assertEqual(len(containers), 1)
+ self.assertIsNotNone(containers[0].find('.//a14:m', NS))
+
+ def test_restored_source_math_gets_visible_text_fallback(self) -> None:
+ slide = self._export(_preserved_formula_shape())
+ wrapper = self._alternate_content(slide)
+ self.assertIsNotNone(wrapper.find('mc:Choice/p:sp//a14:m', NS))
+ fallback = wrapper.find('mc:Fallback', NS)
+ self.assertIsNotNone(fallback)
+ self.assertIsNone(fallback.find('.//a14:m', NS))
+ self.assertEqual(
+ ''.join(node.text or '' for node in fallback.iter(f"{{{NS['a']}}}t")),
+ 'a/b',
+ )
+ self.assertIsNotNone(fallback.find(".//a:srgbClr[@val='F5F5F5']", NS))
+ self._assert_unique_shape_ids(slide)
+
+ def test_fallback_copy_of_placeholder_drops_placeholder_role(self) -> None:
+ slide = self._export(_preserved_formula_shape(
+ ' data-ph-type="body" data-pptx-placeholder-index="1"'
+ ))
+ wrapper = self._alternate_content(slide)
+ self.assertIsNotNone(wrapper.find('mc:Choice/p:sp/p:nvSpPr/p:nvPr/p:ph', NS))
+ self.assertEqual(len(slide.findall('.//p:ph', NS)), 1)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/skills/ppt-master/scripts/tests/test_source_to_md_content_loss_pptx.py b/skills/ppt-master/scripts/tests/test_source_to_md_content_loss_pptx.py
index cc3c5277..5fb2304d 100644
--- a/skills/ppt-master/scripts/tests/test_source_to_md_content_loss_pptx.py
+++ b/skills/ppt-master/scripts/tests/test_source_to_md_content_loss_pptx.py
@@ -12,6 +12,7 @@ import unittest
from contextlib import redirect_stdout
from pathlib import Path
+from lxml import etree
from pptx import Presentation
from pptx.oxml.xmlchemy import OxmlElement
from pptx.util import Inches
@@ -169,3 +170,17 @@ class PptxContentLossTests(unittest.TestCase):
md = self._convert(prs)
self.assertIn('| First<br>Second |', md)
self.assertNotIn('<br><br>', md)
+
+ def test_text_beside_office_math_survives_alternate_content(self) -> None:
+ prs, shape = self._presentation()
+ shape.text = 'ratio holds'
+ sp = shape._element
+ mc = 'http://schemas.openxmlformats.org/markup-compatibility/2006'
+ wrapper = etree.Element(f'{{{mc}}}AlternateContent', nsmap={'mc': mc})
+ choice = etree.SubElement(wrapper, f'{{{mc}}}Choice', Requires='a14')
+ etree.SubElement(wrapper, f'{{{mc}}}Fallback')
+ parent = sp.getparent()
+ parent.replace(sp, wrapper)
+ choice.append(sp)
+ md = self._convert(prs)
+ self.assertIn('ratio holds', md)
diff --git a/skills/ppt-master/scripts/tests/test_text_baseline.py b/skills/ppt-master/scripts/tests/test_text_baseline.py
index 2ed92d96..b450879c 100644
--- a/skills/ppt-master/scripts/tests/test_text_baseline.py
+++ b/skills/ppt-master/scripts/tests/test_text_baseline.py
@@ -34,6 +34,7 @@ from svg_to_pptx.drawingml.converter import convert_svg_to_slide_shapes # noqa:
NS = {
'a': 'http://schemas.openxmlformats.org/drawingml/2006/main',
'm': 'http://schemas.openxmlformats.org/officeDocument/2006/math',
+ 'mc': 'http://schemas.openxmlformats.org/markup-compatibility/2006',
'p': 'http://schemas.openxmlformats.org/presentationml/2006/main',
}
EMU_PER_PX = 9525
@@ -333,6 +334,8 @@ class TextBaselineTests(unittest.TestCase):
'<text x="100" y="200" font-size="40" font-family="Microsoft YaHei">'
'Hg<tspan data-pptx-inline-formula="x">x</tspan>pq</text>'
)
- shape = self._single_shape(slide)
+ shapes = slide.findall('.//mc:Choice/p:sp', NS)
+ self.assertEqual(len(shapes), 1)
+ shape = shapes[0]
self._assert_top(shape, 166)
self.assertIsNotNone(shape.find('.//m:oMath', NS))