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.pyindex 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:+ continueif element.find(".//p:txBody", NS) is not None or element.findall(".//a:t", NS):containers.append(element)return containersdiff --git a/skills/ppt-master/scripts/source_to_md/ppt_to_md.py b/skills/ppt-master/scripts/source_to_md/ppt_to_md.pyindex 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 = 914400DRAWINGML_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.shapediff --git a/skills/ppt-master/scripts/svg_to_pptx/drawingml/converter.py b/skills/ppt-master/scripts/svg_to_pptx/drawingml/converter.pyindex 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_shapefrom ..native_objects.marker_status import native_marker_status_errorsfrom ..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 restoreddef _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.pyindex 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.pyindex 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.pyindex 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.pynew file mode 100644index 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.pyindex 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 unittestfrom contextlib import redirect_stdoutfrom pathlib import Path+from lxml import etreefrom pptx import Presentationfrom pptx.oxml.xmlchemy import OxmlElementfrom 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.pyindex 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))