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(svg_to_pptx): graduate line/area stacking, radar styles, combo, and of-pie native charts

hugohe3e4cd9278af83
diff --git a/skills/ppt-master/references/shared-standards.md b/skills/ppt-master/references/shared-standards.md
index e4df0d71..92c0667e 100644
--- a/skills/ppt-master/references/shared-standards.md
+++ b/skills/ppt-master/references/shared-standards.md
@@ -734,30 +734,37 @@ type, and chart data shape before export.
```
**Category chart schema**: `column`, `bar`, `line`, `area`, `pie`,
-`doughnut`, and `radar` use `categories` plus `series[].values`.
-`pie` and `doughnut` must have exactly one series; the exporter assigns
-per-category slice colors so single-series charts do not collapse into one
-solid color.
+`doughnut`, `pieOfPie`, `barOfPie`, and `radar` use `categories` plus
+`series[].values`. Pie-family charts (`pie`, `doughnut`, `pieOfPie`, and
+`barOfPie`) must have exactly one series; the exporter assigns per-category
+slice colors so single-series charts do not collapse into one solid color.
+
+**Combo chart schema**: `combo` uses shared `categories` plus either `plots[]`
+or typed `series[]`. Each plot supports `type: "column" | "line" | "area"`,
+its own `series`, and optional `axis: "secondary"` for a right-side value axis.
+Typed `series[]` accepts the same `type` and `axis` fields per series, and
+adjacent compatible series are grouped into the same PowerPoint plot.
**XY chart schema**: `scatter` and `bubble` use `series[].x` + `series[].y`; `bubble` also requires one `series[].size` / `series[].sizes` value per point. `series[].points` is also accepted as `[x, y]` / `[x, y, size]` tuples or `{x, y, size}` objects.
-**Deferred chart types**: Stacked / percent-stacked `line` and `area` variants,
-exploded pie / doughnut variants, filled radar, `pieOfPie`, `barOfPie`,
-`stock*`, `combo`, `waterfall`, `funnel`, `treemap`, `sunburst`, `histogram`,
-`pareto`, `boxWhisker`, `map`, `heatmap`, `bullet`, and `gantt` are
-intentionally outside the current native-object support boundary. The exporter
-fails fast for these types until each mapping is implemented and validated one
-by one.
+**Deferred chart types**: Exploded pie / doughnut variants, `stock*`,
+`waterfall`, `funnel`, `treemap`, `sunburst`, `histogram`, `pareto`,
+`boxWhisker`, `map`, `heatmap`, `bullet`, and `gantt` are intentionally outside
+the current native-object support boundary. The exporter fails fast for these
+types until each mapping is implemented and validated one by one.
**Supported chart types**:
- `column`, `bar`: `clustered`, `stacked`, or `percentStacked` (`grouping`)
-- `line`, `area`: standard only
+- `line`: `standard`, `stacked`, or `percentStacked` (`grouping`); `line` or `lineMarker` (`line_style`, default `line` / no markers)
+- `area`: `standard`, `stacked`, or `percentStacked` (`grouping`)
- `pie`: exactly one series, per-slice colors
- `doughnut`: exactly one series, per-slice colors
-- `radar`: marker only
-- `scatter`: `lineMarker`, `line`, `marker`, `smoothMarker`, or `smooth` (`scatter_style`)
+- `pieOfPie`, `barOfPie`: exactly one series, per-slice colors
+- `radar`, `radarMarkers`, `radarFilled`
+- `scatter`: `marker` (default), `lineMarker`, `line`, `smoothMarker`, or `smooth` (`scatter_style`)
- `bubble`: x/y/size series
+- `combo`: `column`, `line`, and `area` plots, optional secondary value axis
3D chart aliases (`3DColumn`, `3DBar`, `3DLine`, `3DArea`, `3DPie`, cone,
cylinder, pyramid variants, and `surface`) are intentionally unsupported. They
diff --git a/skills/ppt-master/scripts/svg_to_pptx/native_objects.py b/skills/ppt-master/scripts/svg_to_pptx/native_objects.py
index 6711f9d5..66613132 100644
--- a/skills/ppt-master/scripts/svg_to_pptx/native_objects.py
+++ b/skills/ppt-master/scripts/svg_to_pptx/native_objects.py
@@ -607,6 +607,7 @@ _CATEGORY_CHART_TYPES = {
"column",
"doughnut",
"line",
+ "of_pie",
"pie",
"radar",
}
@@ -614,13 +615,11 @@ _XY_CHART_TYPES = {"scatter", "bubble"}
_DEFERRED_CHART_TYPES = {
"box_whisker",
"bullet",
- "combo",
"funnel",
"gantt",
"heatmap",
"histogram",
"map",
- "of_pie",
"pareto",
"stock",
"sunburst",
@@ -709,12 +708,17 @@ def _chart_kind(payload: dict[str, Any]) -> tuple[str, str | None, str | None]:
"heatmapchart": ("heatmap", None, None),
"histogram": ("histogram", None, None),
"histogramchart": ("histogram", None, None),
- "line": ("line", "standard", None),
- "linemarkers": ("line", "standard", None),
- "linestacked": ("line", "stacked", None),
- "linestacked100": ("line", "percentStacked", None),
+ "line": ("line", "standard", "line"),
+ "linemarkers": ("line", "standard", "lineMarker"),
+ "linemarkersstacked": ("line", "stacked", "lineMarker"),
+ "linemarkersstacked100": ("line", "percentStacked", "lineMarker"),
+ "linestacked": ("line", "stacked", "line"),
+ "linestacked100": ("line", "percentStacked", "line"),
+ "linestackedmarkers": ("line", "stacked", "lineMarker"),
+ "linestackedmarkers100": ("line", "percentStacked", "lineMarker"),
"pie": ("pie", None, None),
"pieexploded": ("pie", None, "exploded"),
+ "ofpie": ("of_pie", None, "pie"),
"pieofpie": ("of_pie", None, "pie"),
"pareto": ("pareto", None, None),
"paretochart": ("pareto", None, None),
@@ -725,10 +729,10 @@ def _chart_kind(payload: dict[str, Any]) -> tuple[str, str | None, str | None]:
"pyramidcolclustered": ("column3d", "clustered", "pyramid"),
"pyramidcolstacked": ("column3d", "stacked", "pyramid"),
"pyramidcolstacked100": ("column3d", "percentStacked", "pyramid"),
- "radar": ("radar", None, "marker"),
+ "radar": ("radar", None, "line"),
"radarfilled": ("radar", None, "filled"),
- "radarmarkers": ("radar", None, "marker"),
- "scatter": ("scatter", None, "lineMarker"),
+ "radarmarkers": ("radar", None, "lineMarker"),
+ "scatter": ("scatter", None, "marker"),
"stock": ("stock", None, "hlc"),
"stockhlc": ("stock", None, "hlc"),
"stockohlc": ("stock", None, "ohlc"),
@@ -761,8 +765,8 @@ def _chart_kind(payload: dict[str, Any]) -> tuple[str, str | None, str | None]:
"treemapchart": ("treemap", None, None),
"waterfall": ("waterfall", None, None),
"waterfallchart": ("waterfall", None, None),
- "xy": ("scatter", None, "lineMarker"),
- "xyscatter": ("scatter", None, "lineMarker"),
+ "xy": ("scatter", None, "marker"),
+ "xyscatter": ("scatter", None, "marker"),
"xyscatterlines": ("scatter", None, "lineMarker"),
"xyscatterlinesnomarkers": ("scatter", None, "line"),
"xyscattersmooth": ("scatter", None, "smoothMarker"),
@@ -782,7 +786,7 @@ def _chart_kind(payload: dict[str, Any]) -> tuple[str, str | None, str | None]:
f"Native PPTX {chart_type} chart is outside current basic chart support"
)
- supported = sorted(_CATEGORY_CHART_TYPES | _XY_CHART_TYPES)
+ supported = sorted(_CATEGORY_CHART_TYPES | _XY_CHART_TYPES | {"combo"})
if chart_type not in supported:
raise RuntimeError(f"Native PPTX chart type must be one of: {', '.join(supported)}")
return chart_type, grouping, style
@@ -810,11 +814,12 @@ def _chart_grouping(
"standard": "standard",
}
normalized = aliases.get(_compact_key(grouping))
- allowed = (
- {"clustered", "stacked", "percentStacked"}
- if chart_type in {"bar", "column"}
- else {"standard"}
- )
+ if chart_type in {"bar", "column"}:
+ allowed = {"clustered", "stacked", "percentStacked"}
+ elif chart_type in {"area", "line"}:
+ allowed = {"standard", "stacked", "percentStacked"}
+ else:
+ allowed = {"standard"}
if normalized not in allowed:
if normalized in {"clustered", "standard"}:
allowed_text = ", ".join(sorted(allowed))
@@ -825,6 +830,43 @@ def _chart_grouping(
return normalized
+def _line_style(payload: dict[str, Any], alias_style: str | None) -> str:
+ raw_style = payload.get("line_style") or payload.get("lineStyle") or alias_style
+ if raw_style is None:
+ raw_style = "lineMarker" if payload.get("markers") else "line"
+ aliases = {
+ "line": "line",
+ "linemarker": "lineMarker",
+ "marker": "lineMarker",
+ "markers": "lineMarker",
+ "none": "line",
+ "nomarker": "line",
+ "nomarkers": "line",
+ }
+ style = aliases.get(_compact_key(raw_style))
+ if not style:
+ raise RuntimeError("Native PPTX line_style must be one of: line, lineMarker")
+ return style
+
+
+def _radar_style(payload: dict[str, Any], alias_style: str | None) -> tuple[str, str | None]:
+ raw_style = payload.get("radar_style") or payload.get("radarStyle") or alias_style or "line"
+ aliases = {
+ "filled": ("filled", None),
+ "line": ("marker", "none"),
+ "linemarker": ("marker", "circle"),
+ "marker": ("marker", "none"),
+ "markers": ("marker", "circle"),
+ "standard": ("marker", "none"),
+ }
+ style = aliases.get(_compact_key(raw_style))
+ if not style:
+ raise RuntimeError(
+ f"Native PPTX radar_style {raw_style} is outside current basic chart support"
+ )
+ return style
+
+
def _category_series(payload: dict[str, Any], categories: list[str]) -> list[dict[str, Any]]:
raw_series = payload.get("series", [])
if not categories or not isinstance(raw_series, list) or not raw_series:
@@ -853,16 +895,34 @@ def _category_chart_data(
categories = [str(item) for item in _chart_list(payload.get("categories", []), "categories")]
series = _category_series(payload, categories)
- if chart_type in {"doughnut", "pie"}:
+ if chart_type in {"doughnut", "of_pie", "pie"}:
if len(series) != 1:
raise RuntimeError("Native PPTX pie-family charts support exactly one series")
- radar_style = _compact_key(payload.get("radar_style") or alias_style or "marker")
- radar_aliases = {"marker": "marker", "markers": "marker"}
- if chart_type == "radar" and radar_style not in radar_aliases:
- raise RuntimeError(
- f"Native PPTX radar_style {radar_style} is outside current basic chart support"
+ of_pie_type = None
+ if chart_type == "of_pie":
+ raw_of_pie_type = (
+ payload.get("of_pie_type")
+ or payload.get("ofPieType")
+ or payload.get("secondary_type")
+ or alias_style
+ or "pie"
)
+ of_pie_aliases = {
+ "bar": "bar",
+ "barofpie": "bar",
+ "pie": "pie",
+ "pieofpie": "pie",
+ }
+ of_pie_type = of_pie_aliases.get(_compact_key(raw_of_pie_type))
+ if not of_pie_type:
+ raise RuntimeError("Native PPTX of_pie_type must be one of: bar, pie")
+
+ line_style = _line_style(payload, alias_style) if chart_type == "line" else None
+ radar_style = None
+ radar_marker_style = None
+ if chart_type == "radar":
+ radar_style, radar_marker_style = _radar_style(payload, alias_style)
if alias_style == "exploded" or payload.get("exploded"):
raise RuntimeError("Native PPTX exploded pie/doughnut is outside current basic chart support")
@@ -874,11 +934,117 @@ def _category_chart_data(
"grouping": _chart_grouping(chart_type, payload, alias_grouping)
if chart_type in {"bar", "column", "line", "area"}
else None,
- "radar_style": radar_aliases.get(radar_style, "marker"),
+ "of_pie_type": of_pie_type,
+ "line_style": line_style,
+ "radar_marker_style": radar_marker_style,
+ "radar_style": radar_style,
"series": series,
}
+def _combo_axis_name(plot_payload: dict[str, Any]) -> str:
+ axis = plot_payload.get("axis") or plot_payload.get("value_axis")
+ if axis is None and plot_payload.get("secondary_axis"):
+ axis = "secondary"
+ axis_key = _compact_key(axis or "primary")
+ aliases = {
+ "left": "primary",
+ "primary": "primary",
+ "right": "secondary",
+ "secondary": "secondary",
+ "secondaryaxis": "secondary",
+ }
+ normalized = aliases.get(axis_key)
+ if not normalized:
+ raise RuntimeError("Native PPTX combo plot axis must be primary or secondary")
+ return normalized
+
+
+def _combo_plot_type(plot_payload: dict[str, Any]) -> tuple[str, str | None, str | None]:
+ chart_type, alias_grouping, alias_style = _chart_kind(plot_payload)
+ if chart_type not in {"area", "column", "line"}:
+ raise RuntimeError("Native PPTX combo plots support column, line, and area only")
+ return chart_type, alias_grouping, alias_style
+
+
+def _combo_plot_entry(
+ plot_payload: dict[str, Any],
+ categories: list[str],
+ *,
+ fallback_series: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+ chart_type, alias_grouping, alias_style = _combo_plot_type(plot_payload)
+ plot_series = fallback_series or _category_series(plot_payload, categories)
+ entry: dict[str, Any] = {
+ "axis": _combo_axis_name(plot_payload),
+ "grouping": _chart_grouping(chart_type, plot_payload, alias_grouping)
+ if chart_type in {"area", "column", "line"}
+ else None,
+ "series": plot_series,
+ "type": chart_type,
+ }
+ if chart_type == "line":
+ entry["line_style"] = _line_style(plot_payload, alias_style)
+ return entry
+
+
+def _combo_chart_data(payload: dict[str, Any]) -> dict[str, Any]:
+ categories = [str(item) for item in _chart_list(payload.get("categories", []), "categories")]
+ raw_plots = payload.get("plots", payload.get("chart_plots"))
+ plots: list[dict[str, Any]] = []
+
+ if raw_plots is not None:
+ for item in _chart_list(raw_plots, "plots"):
+ if not isinstance(item, dict):
+ raise RuntimeError("Native PPTX combo plots must be objects")
+ plots.append(_combo_plot_entry(item, categories))
+ else:
+ raw_series = _chart_list(payload.get("series", []), "series")
+ if not raw_series:
+ raise RuntimeError("Native PPTX combo chart requires plots or typed series")
+ for idx, item in enumerate(raw_series, start=1):
+ if not isinstance(item, dict):
+ raise RuntimeError("Native PPTX chart series entries must be objects")
+ if not (item.get("type") or item.get("chart_type")):
+ raise RuntimeError("Native PPTX combo series entries require type")
+ one_series = _category_series({"series": [item]}, categories)
+ plot = _combo_plot_entry(item, categories, fallback_series=one_series)
+ signature = (
+ plot["axis"],
+ plot.get("grouping"),
+ plot.get("line_style"),
+ plot["type"],
+ )
+ previous = plots[-1] if plots else None
+ previous_signature = (
+ previous.get("axis"),
+ previous.get("grouping"),
+ previous.get("line_style"),
+ previous.get("type"),
+ ) if previous else None
+ if previous is not None and signature == previous_signature:
+ previous["series"].extend(plot["series"])
+ else:
+ plots.append(plot)
+
+ if not plots:
+ raise RuntimeError("Native PPTX combo chart requires at least one plot")
+ flat_series: list[dict[str, Any]] = []
+ for plot in plots:
+ plot["start_index"] = len(flat_series)
+ flat_series.extend(plot["series"])
+ if not flat_series:
+ raise RuntimeError("Native PPTX combo chart requires at least one series")
+
+ return {
+ "categories": categories,
+ "kind": "combo",
+ "plots": plots,
+ "series": flat_series,
+ "type": "combo",
+ }
+
+
def _point_values(point: Any, *, chart_type: str) -> tuple[Any, Any, Any | None]:
if isinstance(point, dict):
return point.get("x"), point.get("y"), point.get("size", point.get("bubble_size"))
@@ -938,7 +1104,7 @@ def _xy_chart_data(
"y": y_values,
})
- scatter_style = _compact_key(payload.get("scatter_style") or alias_style or "lineMarker")
+ scatter_style = _compact_key(payload.get("scatter_style") or alias_style or "marker")
style_aliases = {
"line": "line",
"linemarker": "lineMarker",
@@ -952,13 +1118,15 @@ def _xy_chart_data(
return {
"kind": "xy",
"type": chart_type,
- "scatter_style": style_aliases.get(scatter_style, "lineMarker"),
+ "scatter_style": style_aliases.get(scatter_style, "marker"),
"series": series,
}
def _chart_data(payload: dict[str, Any]) -> dict[str, Any]:
chart_type, alias_grouping, alias_style = _chart_kind(payload)
+ if chart_type == "combo":
+ return _combo_chart_data(payload)
if chart_type in _XY_CHART_TYPES:
return _xy_chart_data(payload, chart_type, alias_style)
return _category_chart_data(payload, chart_type, alias_grouping, alias_style)
@@ -1012,11 +1180,21 @@ def _data_point_colors_xml(count: int, colors: list[str]) -> str:
)
+def _marker_xml(symbol: str | None) -> str:
+ if not symbol:
+ return ""
+ if symbol == "none":
+ return '<c:marker><c:symbol val="none"/></c:marker>'
+ return f'<c:marker><c:symbol val="{_xml_escape(symbol)}"/></c:marker>'
+
+
def _series_xml(
categories: list[str],
series: list[dict[str, Any]],
*,
chart_type: str,
+ line_style: str = "line",
+ radar_marker_style: str | None = None,
radar_style: str = "marker",
colors: list[str],
start_column: int = 2,
@@ -1028,11 +1206,23 @@ def _series_xml(
column_index = offset + start_column
color_xml = _series_color_xml(_chart_color(colors, index))
point_colors_xml = ""
- if chart_type in {"doughnut", "pie"}:
+ marker_xml = ""
+ smooth_xml = ""
+ if chart_type in {"doughnut", "of_pie", "pie"}:
color_xml = ""
- point_colors_xml = _data_point_colors_xml(len(categories), colors)
- marker_xml = '<c:marker><c:symbol val="circle"/></c:marker>' if chart_type == "line" else ""
- smooth_xml = '<c:smooth val="0"/>' if chart_type == "line" else ""
+ point_count = (
+ len(categories) + 1
+ if chart_type == "of_pie"
+ else len(categories)
+ )
+ point_colors_xml = _data_point_colors_xml(point_count, colors)
+ if chart_type == "line":
+ marker_xml = _marker_xml("circle" if line_style == "lineMarker" else "none")
+ smooth_xml = '<c:smooth val="0"/>'
+ if chart_type == "radar":
+ if radar_style == "filled":
+ color_xml = _series_color_xml(_chart_color(colors, index), line=False)
+ marker_xml = _marker_xml(radar_marker_style)
parts.append(
"<c:ser>"
f'<c:idx val="{index}"/><c:order val="{index}"/>'
@@ -1157,10 +1347,147 @@ def _xy_series_xml(
return "".join(parts)
+def _bar_chart_group_xml(
+ chart_type: str,
+ grouping: str,
+ ser_xml: str,
+ *,
+ cat_ax_id: str,
+ val_ax_id: str,
+) -> str:
+ bar_dir = "bar" if chart_type == "bar" else "col"
+ overlap_xml = (
+ '<c:overlap val="100"/>'
+ if grouping in {"stacked", "percentStacked"}
+ else ""
+ )
+ return (
+ "<c:barChart>"
+ f'<c:barDir val="{bar_dir}"/><c:grouping val="{grouping}"/>'
+ '<c:varyColors val="0"/>'
+ f"{ser_xml}"
+ '<c:gapWidth val="150"/>'
+ f"{overlap_xml}"
+ f'<c:axId val="{cat_ax_id}"/><c:axId val="{val_ax_id}"/>'
+ "</c:barChart>"
+ )
+
+
+def _line_area_chart_group_xml(
+ chart_type: str,
+ grouping: str,
+ ser_xml: str,
+ *,
+ cat_ax_id: str,
+ val_ax_id: str,
+) -> str:
+ tag = "lineChart" if chart_type == "line" else "areaChart"
+ line_tail_xml = '<c:marker val="1"/><c:smooth val="0"/>' if chart_type == "line" else ""
+ return (
+ f'<c:{tag}><c:grouping val="{grouping}"/><c:varyColors val="0"/>'
+ f"{ser_xml}"
+ f"{line_tail_xml}"
+ f'<c:axId val="{cat_ax_id}"/><c:axId val="{val_ax_id}"/>'
+ f"</c:{tag}>"
+ )
+
+
+def _secondary_axis_xml(cat_ax_id: str, val_ax_id: str, *, grouping: str | None = None) -> str:
+ val_num_fmt = (
+ '<c:numFmt formatCode="0%" sourceLinked="0"/>'
+ if grouping == "percentStacked"
+ else ""
+ )
+ return (
+ "<c:catAx>"
+ f'<c:axId val="{cat_ax_id}"/><c:scaling><c:orientation val="minMax"/></c:scaling>'
+ '<c:delete val="1"/><c:axPos val="b"/><c:majorTickMark val="none"/>'
+ '<c:minorTickMark val="none"/><c:tickLblPos val="nextTo"/>'
+ f'<c:crossAx val="{val_ax_id}"/><c:crosses val="max"/><c:auto val="1"/>'
+ '<c:lblAlgn val="ctr"/><c:lblOffset val="100"/><c:noMultiLvlLbl val="0"/>'
+ "</c:catAx>"
+ "<c:valAx>"
+ f'<c:axId val="{val_ax_id}"/><c:scaling><c:orientation val="minMax"/></c:scaling>'
+ f'<c:delete val="0"/><c:axPos val="r"/>{val_num_fmt}'
+ '<c:majorTickMark val="out"/><c:minorTickMark val="none"/>'
+ '<c:tickLblPos val="nextTo"/>'
+ f'<c:crossAx val="{cat_ax_id}"/><c:crosses val="max"/>'
+ "</c:valAx>"
+ )
+
+
+def _combo_axis_grouping(plots: list[dict[str, Any]], axis: str) -> str | None:
+ for plot in plots:
+ if plot.get("axis") == axis and plot.get("grouping") == "percentStacked":
+ return "percentStacked"
+ return None
+
+
+def _combo_plot_xml(chart_data: dict[str, Any], colors: list[str]) -> str:
+ categories = chart_data["categories"]
+ primary_cat_ax_id = "2068027336"
+ primary_val_ax_id = "2113994440"
+ secondary_cat_ax_id = "2080229232"
+ secondary_val_ax_id = "2098941040"
+ parts: list[str] = []
+
+ for plot in chart_data["plots"]:
+ chart_type = plot["type"]
+ axis = plot.get("axis", "primary")
+ cat_ax_id = secondary_cat_ax_id if axis == "secondary" else primary_cat_ax_id
+ val_ax_id = secondary_val_ax_id if axis == "secondary" else primary_val_ax_id
+ start_index = int(plot.get("start_index", 0))
+ ser_xml = _series_xml(
+ categories,
+ plot["series"],
+ chart_type=chart_type,
+ colors=colors,
+ line_style=plot.get("line_style", "line"),
+ start_column=2 + start_index,
+ start_index=start_index,
+ )
+ grouping = plot.get("grouping") or ("clustered" if chart_type == "column" else "standard")
+ if chart_type == "column":
+ parts.append(_bar_chart_group_xml(
+ chart_type,
+ grouping,
+ ser_xml,
+ cat_ax_id=cat_ax_id,
+ val_ax_id=val_ax_id,
+ ))
+ elif chart_type in {"area", "line"}:
+ parts.append(_line_area_chart_group_xml(
+ chart_type,
+ grouping,
+ ser_xml,
+ cat_ax_id=cat_ax_id,
+ val_ax_id=val_ax_id,
+ ))
+ else:
+ raise RuntimeError("Native PPTX combo plots support column, line, and area only")
+
+ has_secondary_axis = any(plot.get("axis") == "secondary" for plot in chart_data["plots"])
+ axes_xml = _axis_xml(
+ primary_cat_ax_id,
+ primary_val_ax_id,
+ chart_type="column",
+ grouping=_combo_axis_grouping(chart_data["plots"], "primary"),
+ )
+ if has_secondary_axis:
+ axes_xml += _secondary_axis_xml(
+ secondary_cat_ax_id,
+ secondary_val_ax_id,
+ grouping=_combo_axis_grouping(chart_data["plots"], "secondary"),
+ )
+ return "".join(parts) + axes_xml
+
+
def _chart_plot_xml(chart_data: dict[str, Any], colors: list[str]) -> str:
chart_type = chart_data["type"]
cat_ax_id = "2068027336"
val_ax_id = "2113994440"
+ if chart_data["kind"] == "combo":
+ return _combo_plot_xml(chart_data, colors)
if chart_data["kind"] == "xy":
x_ax_id = "2080229232"
y_ax_id = "2098941040"
@@ -1195,6 +1522,8 @@ def _chart_plot_xml(chart_data: dict[str, Any], colors: list[str]) -> str:
categories,
series,
chart_type=chart_type,
+ line_style=chart_data.get("line_style", "line"),
+ radar_marker_style=chart_data.get("radar_marker_style"),
radar_style=chart_data.get("radar_style", "marker"),
colors=colors,
)
@@ -1220,20 +1549,31 @@ def _chart_plot_xml(chart_data: dict[str, Any], colors: list[str]) -> str:
if chart_type in {"line", "area"}:
tag = "lineChart" if chart_type == "line" else "areaChart"
grouping = chart_data.get("grouping") or "standard"
+ line_tail_xml = '<c:marker val="1"/><c:smooth val="0"/>' if chart_type == "line" else ""
return (
f'<c:{tag}><c:grouping val="{grouping}"/><c:varyColors val="0"/>'
f"{ser_xml}"
+ f"{line_tail_xml}"
f'<c:axId val="{cat_ax_id}"/><c:axId val="{val_ax_id}"/>'
f"</c:{tag}>"
- f'{_axis_xml(cat_ax_id, val_ax_id, chart_type=chart_type)}'
+ f'{_axis_xml(cat_ax_id, val_ax_id, chart_type=chart_type, grouping=grouping)}'
)
if chart_type == "doughnut":
return (
'<c:doughnutChart><c:varyColors val="1"/>'
f"{ser_xml}"
- '<c:firstSliceAng val="0"/><c:holeSize val="50"/>'
+ '<c:firstSliceAng val="0"/><c:holeSize val="75"/>'
"</c:doughnutChart>"
)
+ if chart_type == "of_pie":
+ of_pie_type = chart_data.get("of_pie_type", "pie")
+ return (
+ f'<c:ofPieChart><c:ofPieType val="{of_pie_type}"/>'
+ '<c:varyColors val="1"/>'
+ f"{ser_xml}"
+ '<c:gapWidth val="100"/><c:secondPieSize val="75"/><c:serLines/>'
+ "</c:ofPieChart>"
+ )
if chart_type == "radar":
radar_style = chart_data.get("radar_style", "marker")
return (