434 lines
23 KiB
Python
434 lines
23 KiB
Python
#!/usr/bin/env python3
|
||
"""Render a data-bound SVG component with a native PowerPoint Chart marker."""
|
||
from __future__ import annotations
|
||
|
||
import argparse
|
||
from copy import deepcopy
|
||
import json
|
||
import math
|
||
from pathlib import Path
|
||
import re
|
||
import sys
|
||
import unicodedata
|
||
import xml.etree.ElementTree as ET
|
||
|
||
import template_ref as ref
|
||
|
||
SVG = "http://www.w3.org/2000/svg"
|
||
ET.register_namespace("", SVG)
|
||
TYPES = ("column", "bar", "line", "scatter", "pie", "doughnut", "column-stacked")
|
||
ID = re.compile(r"^[A-Za-z][A-Za-z0-9_-]{0,63}$")
|
||
|
||
|
||
def require(condition, message):
|
||
if not condition:
|
||
raise ValueError(message)
|
||
|
||
|
||
def number(value, name):
|
||
require(isinstance(value, (int, float)) and not isinstance(value, bool), f"{name}: number required")
|
||
require(math.isfinite(value), f"{name}: finite number required")
|
||
# The SVG and OOXML scalar calculations must not overflow or underflow.
|
||
require(value == 0 or 1e-9 <= abs(value) <= 1e12, f"{name}: supported nonzero magnitude is 1e-9..1e12")
|
||
return value
|
||
|
||
|
||
def text(value, name, *, empty=False):
|
||
require(isinstance(value, str) and (empty or bool(value.strip())), f"{name}: {'string' if empty else 'nonempty string'} required")
|
||
require(not any(unicodedata.category(c).startswith('C') for c in value), f"{name}: control/format characters unsupported")
|
||
return value
|
||
|
||
|
||
def fields(value, allowed, required, name):
|
||
require(isinstance(value, dict), f"{name}: object required")
|
||
require(set(value) <= allowed, f"{name}: unknown fields {sorted(set(value) - allowed)}")
|
||
require(required <= set(value), f"{name}: missing fields {sorted(required - set(value))}")
|
||
|
||
|
||
def validate_data(raw):
|
||
fields(raw, {"schema_version", "data_kind", "type", "title", "unit", "x_unit", "source", "categories", "series"},
|
||
{"schema_version", "data_kind", "type", "title", "unit", "series"}, "chart")
|
||
require(type(raw['schema_version']) is int and raw['schema_version'] == 1, "chart schema_version must be 1")
|
||
require(raw['data_kind'] in ('synthetic-demo', 'observed', 'derived'), "data_kind must be synthetic-demo, observed or derived")
|
||
require(raw['type'] in TYPES, f"type must be one of {TYPES}")
|
||
for key in ('title', 'unit'):
|
||
text(raw[key], key, empty=key == 'unit')
|
||
for key in ('source', 'x_unit'):
|
||
if key in raw:
|
||
text(raw[key], key, empty=True)
|
||
kind = raw['type']
|
||
if kind == 'scatter':
|
||
require('categories' not in raw, "scatter uses series.points, not categories")
|
||
else:
|
||
require('x_unit' not in raw, "x_unit is supported for scatter only")
|
||
require(isinstance(raw.get('categories'), list) and bool(raw['categories']), "categories must be nonempty list")
|
||
for category in raw['categories']:
|
||
text(category, 'category')
|
||
require(len(set(raw['categories'])) == len(raw['categories']), "category labels must be unique")
|
||
require(isinstance(raw['series'], list) and bool(raw['series']), "series must be nonempty list")
|
||
series_ids = set()
|
||
for s in raw['series']:
|
||
fields(s, {'id', 'name', 'points'} if kind == 'scatter' else {'id', 'name', 'values'},
|
||
{'id', 'name', 'points'} if kind == 'scatter' else {'id', 'name', 'values'}, 'series')
|
||
require(isinstance(s['id'], str) and ID.fullmatch(s['id']), "series id must be stable SVG-safe ID")
|
||
require(s['id'] not in series_ids, 'series IDs must be unique')
|
||
series_ids.add(s['id'])
|
||
text(s['name'], 'series.name')
|
||
values = s.get('points') if kind == 'scatter' else s.get('values')
|
||
require(isinstance(values, list) and bool(values), 'series data must be nonempty list')
|
||
if kind == 'scatter':
|
||
for point in values:
|
||
require(isinstance(point, list) and len(point) == 2, 'scatter point must be [x, y]')
|
||
for val in point:
|
||
number(val, 'scatter coordinate')
|
||
else:
|
||
require(len(values) == len(raw['categories']), 'series values must match categories length')
|
||
for val in values:
|
||
number(val, 'series value')
|
||
if kind in ('pie', 'doughnut', 'column-stacked'):
|
||
require(val >= 0, f'{kind} initial support requires nonnegative values')
|
||
if kind in ('pie', 'doughnut'):
|
||
require(len(raw['series']) == 1, 'pie/doughnut requires exactly one series')
|
||
require(sum(raw['series'][0]['values']) > 0, 'pie/doughnut requires positive total')
|
||
return deepcopy(raw)
|
||
|
||
|
||
def _n(value):
|
||
return f'{value:.10g}'
|
||
|
||
|
||
def _node(parent, tag, **attrs):
|
||
return ET.SubElement(parent, '{' + SVG + '}' + tag, {k.replace('_', '-'): _n(v) if isinstance(v, (float, int)) else str(v) for k, v in attrs.items()})
|
||
|
||
|
||
def _text(parent, x, y, value, font, size, color, anchor='start'):
|
||
node = _node(parent, 'text', x=x, y=y, fill=color, font_family=font, font_size=size, text_anchor=anchor)
|
||
node.text = value
|
||
return node
|
||
|
||
|
||
def _width(value, size):
|
||
# Conservative capacity check, not a substitute for application rendering.
|
||
return sum(1 if unicodedata.east_asian_width(c) in ('W', 'F') else .6 for c in value) * size
|
||
|
||
|
||
def _fit(value, size, width, name):
|
||
require(_width(value, size) <= width, f'{name} exceeds available width; shorten text or enlarge bounds (font is not reduced)')
|
||
|
||
|
||
def _range(values):
|
||
low, high = min(0, min(values)), max(0, max(values))
|
||
if low == high:
|
||
return 0.0, 1.0, .25
|
||
span = high - low
|
||
exponent = math.floor(math.log10(span / 4))
|
||
base = 10.0 ** exponent
|
||
raw = span / 4 / base
|
||
step = next(candidate for candidate in (1, 2, 2.5, 5, 10) if candidate >= raw) * base
|
||
low = math.floor(low / step) * step
|
||
high = math.ceil(high / step) * step
|
||
return low, high, step
|
||
|
||
|
||
def _ticks(scale):
|
||
low, high, step = scale
|
||
return [low + i * step for i in range(round((high - low) / step) + 1)]
|
||
|
||
|
||
def _label(value):
|
||
return '0' if abs(value) < 1e-14 else f'{value:.6g}'
|
||
|
||
|
||
def _axis(scale):
|
||
low, high, step = scale
|
||
return {'minimum': low, 'maximum': high, 'major_unit': step,
|
||
'major_gridlines': True, 'label_position': 'low',
|
||
'number_format': '0.######E+00' if max(abs(low), abs(high)) >= 1e6 or 0 < step < .001 else 'General'}
|
||
|
||
|
||
def _style(style, theme):
|
||
require(isinstance(style, dict) and isinstance(theme, dict), 'style/theme must be objects')
|
||
chart = style.get('components', {}).get('charts', {})
|
||
require(isinstance(chart, dict), 'style.components.charts must be object')
|
||
typography = style['typography']
|
||
role = chart.get('text_role', 'caption' if 'caption' in typography['roles'] else 'label')
|
||
require(role in typography['roles'], 'chart text_role missing from typography.roles')
|
||
label = typography['roles'][role]
|
||
family = typography['families']['body']['family']
|
||
px_per_pt = number(style['canvas']['pt_to_px'], 'canvas.pt_to_px')
|
||
require(px_per_pt > 0, 'canvas.pt_to_px must be positive')
|
||
size = number(label['size_pt'], 'chart size_pt') * px_per_pt
|
||
require(size > 0, 'chart text size must be positive')
|
||
palette = theme['palette']
|
||
indices = chart.get('series_palette_indices', [k for k in ('accent1', 'accent3', 'accent4', 'accent5', 'accent6', 'accent2') if k in palette])
|
||
require(isinstance(indices, list) and bool(indices), 'series_palette_indices must be nonempty list')
|
||
require(len(set(indices)) == len(indices), 'series_palette_indices must be unique')
|
||
keys = [*indices, chart.get('text_palette_index', 'dk1'), chart.get('grid_palette_index', 'line' if 'line' in palette else 'dk2'), 'lt1']
|
||
axis_index = chart.get('axis_palette_index', chart.get('text_palette_index', 'dk1'))
|
||
require(isinstance(axis_index, str) and axis_index in palette and re.fullmatch(r'#[0-9A-Fa-f]{6}', palette[axis_index]), 'invalid/missing axis_palette_index')
|
||
for key in keys:
|
||
require(isinstance(key, str) and key in palette and re.fullmatch(r'#[0-9A-Fa-f]{6}', palette[key]), f'invalid/missing palette color: {key}')
|
||
return family, size, [palette[k] for k in indices], palette[keys[-3]], palette[keys[-2]], palette['lt1'], palette[axis_index]
|
||
|
||
|
||
def render_chart(data: dict, style: dict, theme: dict,
|
||
bounds: tuple[float, float, float, float], component_id: str) -> ET.Element:
|
||
"""Return an isolated SVG g; insert it into the caller's selected page/Layout.
|
||
|
||
Metadata and visible fallback share validated input. bar deliberately leaves
|
||
axes automatic in native Office, because the pinned compiler cannot configure
|
||
bar axes. Its SVG ticks therefore preview a scale, not Office's eventual ticks.
|
||
"""
|
||
data = validate_data(data)
|
||
require(isinstance(component_id, str) and ID.fullmatch(component_id), 'component_id must be SVG-safe ID')
|
||
require(isinstance(bounds, (tuple, list)) and len(bounds) == 4, 'bounds must be [x, y, width, height]')
|
||
x, y, w, h = [number(v, 'bounds') for v in bounds]
|
||
require(x >= 0 and y >= 0 and w > 0 and h > 0, 'bounds must have nonnegative origin and positive size')
|
||
canvas = style['canvas']
|
||
require(x + w <= canvas['width'] and y + h <= canvas['height'], 'component bounds exceed template canvas')
|
||
font, fs, colors, ink, grid, background, axis_color = _style(style, theme)
|
||
require(w >= fs * 14 and h >= fs * 14, 'bounds too small for declared chart font and annotations')
|
||
kind = data['type']
|
||
value_labels = style.get('components', {}).get('charts', {}).get('value_labels', False)
|
||
require(type(value_labels) is bool, 'chart value_labels must be boolean')
|
||
if value_labels:
|
||
require(kind == 'column', 'optional value_labels supports nonnegative grouped column only; bar already labels values')
|
||
require(all(value >= 0 for series in data['series'] for value in series['values']),
|
||
'optional column value_labels requires nonnegative values')
|
||
pie = kind in ('pie', 'doughnut')
|
||
count = len(data['categories']) if pie else len(data['series'])
|
||
require(count <= len(colors), 'insufficient distinct palette indices for series/slices; configure style.components.charts')
|
||
colors = colors[:count]
|
||
source = data.get('source', '')
|
||
source_line = ('示例数据（合成）' if data['data_kind'] == 'synthetic-demo' else '')
|
||
if source:
|
||
source_line += ('；' if source_line else '') + '来源：' + source
|
||
if kind == 'scatter':
|
||
unit_parts = []
|
||
if data.get('x_unit'):
|
||
unit_parts.append('X：' + data['x_unit'])
|
||
if data['unit']:
|
||
unit_parts.append('Y：' + data['unit'])
|
||
unit = '；'.join(unit_parts)
|
||
else:
|
||
unit = '单位：' + data['unit'] if data['unit'] else ''
|
||
for value, name in ((data['title'], 'title'), (unit, 'unit'), (source_line, 'source')):
|
||
_fit(value, fs, w - 16, name)
|
||
outer = ET.Element('{' + SVG + '}g', {'id': component_id, 'data-component': 'chart', 'data-chart-type': kind})
|
||
_text(outer, x + 8, y + fs, data['title'], font, fs, ink)
|
||
top = y + math.ceil((fs + 16) / 8) * 8
|
||
if unit:
|
||
_text(outer, x + 8, top + fs, unit, font, fs, ink)
|
||
top += math.ceil((fs + 8) / 8) * 8
|
||
bottom = y + h - (math.ceil((fs + 8) / 8) * 8 if source_line else 8)
|
||
if source_line:
|
||
_text(outer, x + 8, y + h - 8, source_line, font, fs, ink)
|
||
|
||
legends = [f'{c} {_label(v)}' for c, v in zip(data.get('categories', []), data['series'][0].get('values', []))] if pie else [s['name'] for s in data['series']]
|
||
legend_widths = [32 + _width(label, fs) + 16 for label in legends]
|
||
require(all(lw <= w - 16 for lw in legend_widths), 'legend label too wide for bounds')
|
||
rows, row = [], []
|
||
used = 0
|
||
for index, width in enumerate(legend_widths):
|
||
if row and used + width > w - 16:
|
||
rows.append(row);row = [];used = 0
|
||
row.append((index, width));used += width
|
||
if row:
|
||
rows.append(row)
|
||
legend_h = len(rows) * math.ceil((fs + 8) / 8) * 8
|
||
legend_y = bottom - legend_h
|
||
for r, items in enumerate(rows):
|
||
lx = x + 8
|
||
ly = legend_y + r * math.ceil((fs + 8) / 8) * 8 + fs
|
||
for idx, width in items:
|
||
_node(outer, 'rect', x=lx, y=ly-fs*.65, width=16, height=16, fill=colors[idx])
|
||
_text(outer, lx+24, ly, legends[idx], font, fs, ink)
|
||
lx += width
|
||
chart_h = legend_y - top - 8
|
||
require(chart_h >= fs * 7, 'chart/legend/source too tall for bounds; enlarge region or reduce categories/legend text')
|
||
marker = _node(outer, 'g', id=component_id+'-native', data_pptx_replace_with='chart')
|
||
payload = {'name': component_id, 'x': x, 'y': top, 'width': w, 'height': chart_h,
|
||
'type': 'column' if kind == 'column-stacked' else kind,
|
||
'show_legend': False,
|
||
'style': {'colors': colors, 'font_family': font, 'font_size': fs, 'axis_font_size': fs,
|
||
'text_color': ink, 'axis_color': axis_color, 'grid_color': grid,
|
||
'chart_area_fill': background, 'plot_area_fill': background},
|
||
'component_data': deepcopy(data)}
|
||
metadata = _node(marker, 'metadata', type='application/json')
|
||
if value_labels:
|
||
payload['data_labels'] = {'position': 'outside_end', 'show_value': True,
|
||
'font_size': fs, 'color': ink, 'number_format': 'General'}
|
||
if kind == 'line':
|
||
payload['markers'] = True
|
||
fallback = _node(marker, 'g', id=component_id+'-fallback')
|
||
_node(fallback, 'rect', x=x, y=top, width=w, height=chart_h, fill=background)
|
||
if kind == 'scatter':
|
||
payload['series'] = [{'name': s['name'], 'points': s['points']} for s in data['series']]
|
||
xs = [p[0] for s in data['series'] for p in s['points']]
|
||
ys = [p[1] for s in data['series'] for p in s['points']]
|
||
xscale, yscale = _range(xs), _range(ys)
|
||
payload['axes'] = {'x': _axis(xscale), 'y': _axis(yscale)}
|
||
else:
|
||
payload['categories'] = data['categories']
|
||
payload['series'] = [{'name': s['name'], 'values': s['values']} for s in data['series']]
|
||
if kind == 'column-stacked':
|
||
payload['grouping'] = 'stacked'
|
||
if not pie:
|
||
values = ([sum(s['values'][i] for s in data['series']) for i in range(len(data['categories']))]
|
||
if kind == 'column-stacked' else [v for s in data['series'] for v in s['values']])
|
||
yscale = _range(values)
|
||
if kind != 'bar':
|
||
payload['axes'] = {'category': {'label_position': 'low', 'major_gridlines': False}, 'value': _axis(yscale)}
|
||
else:
|
||
payload['data_labels'] = {'position': 'outside_end'}
|
||
payload['show_value_axis_labels'] = True
|
||
outer.set('data-native-axis-policy', 'automatic-bar-preview-scale-may-differ')
|
||
if pie:
|
||
diameter = min(w - 32, chart_h - 16)
|
||
radius = diameter / 2
|
||
cx, cy = x+w/2, top+chart_h/2
|
||
total = sum(data['series'][0]['values'])
|
||
angle = -math.pi / 2
|
||
for i, val in enumerate(data['series'][0]['values']):
|
||
if val == 0:
|
||
continue
|
||
end = angle + val / total * math.tau
|
||
if math.isclose(val, total):
|
||
_node(fallback, 'circle', cx=cx, cy=cy, r=radius, fill=colors[i])
|
||
else:
|
||
start_x, start_y = cx+radius*math.cos(angle), cy+radius*math.sin(angle)
|
||
end_x, end_y = cx+radius*math.cos(end), cy+radius*math.sin(end)
|
||
path = f'M {_n(cx)} {_n(cy)} L {_n(start_x)} {_n(start_y)} A {_n(radius)} {_n(radius)} 0 {int(end-angle > math.pi)} 1 {_n(end_x)} {_n(end_y)} Z'
|
||
_node(fallback, 'path', d=path, fill=colors[i])
|
||
angle = end
|
||
if kind == 'doughnut':
|
||
# The pinned native writer fixes holeSize to 75%.
|
||
_node(fallback, 'circle', cx=cx, cy=cy, r=radius*.75, fill=background)
|
||
elif kind == 'bar':
|
||
ticks = _ticks(yscale)
|
||
labels_width = max(_width(c, fs) for c in data['categories']) + 16
|
||
value_width = max(_width(_label(v), fs) for s in data['series'] for v in s['values'])
|
||
left, right = x + labels_width + value_width + 8, x+w-value_width-16
|
||
pt, pb = top+8, top+chart_h-fs-16
|
||
require(right-left >= fs*7, 'bar category labels leave insufficient plot width')
|
||
low, high, step = yscale
|
||
xp = lambda val: left+(val-low)/(high-low)*(right-left)
|
||
for tick in ticks:
|
||
_node(fallback, 'line', x1=xp(tick), y1=pt, x2=xp(tick), y2=pb, stroke=grid, stroke_width=1)
|
||
_text(fallback, xp(tick), pb+fs+8, _label(tick), font, fs, ink, 'middle')
|
||
band = (pb-pt)/len(data['categories'])
|
||
bw = band/(len(data['series'])+1.5)
|
||
require(band >= fs+8 and bw >= fs+4, 'too many bar categories/series for fixed labels and bounds')
|
||
for i, category in enumerate(data['categories']):
|
||
center = pt+(i+.5)*band
|
||
_text(fallback, x+labels_width-8, center+fs*.35, category, font, fs, ink, 'end')
|
||
for j, s in enumerate(data['series']):
|
||
value = s['values'][i]
|
||
x0, x1 = xp(0), xp(value)
|
||
bar_y = center-(len(data['series'])*bw)/2+j*bw
|
||
_node(fallback, 'rect', x=min(x0,x1), y=bar_y, width=abs(x1-x0), height=bw, fill=colors[j])
|
||
_text(fallback, x1 + (8 if value >= 0 else -8), bar_y+bw/2+fs*.35, _label(value), font, fs, ink, 'start' if value >= 0 else 'end')
|
||
else:
|
||
ticks = _ticks(yscale)
|
||
tick_width = max(_width(_label(t), fs) for t in ticks)
|
||
left, right = x+tick_width+16, x+w-16
|
||
pt, pb = top+8, top+chart_h-fs-16
|
||
require(right-left >= fs*7 and (pb-pt)/(len(ticks)-1) >= fs+4, 'axis labels leave insufficient plot area')
|
||
low, high, step = yscale
|
||
yp = lambda val: pb-(val-low)/(high-low)*(pb-pt)
|
||
for tick in ticks:
|
||
_node(fallback, 'line', x1=left, y1=yp(tick), x2=right, y2=yp(tick), stroke=axis_color if abs(tick)<step*1e-6 else grid, stroke_width=1)
|
||
_text(fallback, left-8, yp(tick)+fs*.35, _label(tick), font, fs, ink, 'end')
|
||
if kind == 'scatter':
|
||
xl, xh, _ = xscale
|
||
xp = lambda val: left+(val-xl)/(xh-xl)*(right-left)
|
||
xticks = _ticks(xscale)
|
||
require((right-left)/(len(xticks)-1) >= max(_width(_label(t),fs) for t in xticks)+8, 'scatter X tick labels too crowded')
|
||
for tick in xticks:
|
||
_node(fallback, 'line', x1=xp(tick), y1=pt, x2=xp(tick), y2=pb, stroke=grid, stroke_width=1)
|
||
_text(fallback, xp(tick), pb+fs+8, _label(tick), font, fs, ink, 'middle')
|
||
for j, s in enumerate(data['series']):
|
||
for vx, vy in s['points']:
|
||
_node(fallback, 'circle', cx=xp(vx), cy=yp(vy), r=5, fill=colors[j])
|
||
else:
|
||
band = (right-left)/len(data['categories'])
|
||
for i, category in enumerate(data['categories']):
|
||
_fit(category, fs, band-8, 'category')
|
||
center = left+(i+.5)*band
|
||
_text(fallback, center, pb+fs+8, category, font, fs, ink, 'middle')
|
||
if kind in ('column', 'column-stacked'):
|
||
bw = band/(len(data['series'])+1.5) if kind == 'column' else band/2.5
|
||
require(bw >= 8, 'too many series/categories for plot width')
|
||
accumulated = 0
|
||
for j, s in enumerate(data['series']):
|
||
val = s['values'][i]
|
||
bottom_value = accumulated if kind == 'column-stacked' else 0
|
||
top_value = bottom_value+val
|
||
xpos = center-bw/2 if kind == 'column-stacked' else center-len(data['series'])*bw/2+j*bw
|
||
_node(fallback, 'rect', x=xpos, y=min(yp(top_value),yp(bottom_value)), width=bw, height=abs(yp(top_value)-yp(bottom_value)), fill=colors[j])
|
||
if value_labels:
|
||
_fit(_label(val), fs, bw - 4, 'column value label')
|
||
_text(fallback, xpos+bw/2, yp(val)-8, _label(val), font, fs, ink, 'middle')
|
||
accumulated += val
|
||
if kind == 'line':
|
||
payload['line_style'] = 'lineMarker'
|
||
for j, s in enumerate(data['series']):
|
||
points = [(left+(i+.5)*band, yp(v)) for i,v in enumerate(s['values'])]
|
||
_node(fallback, 'polyline', points=' '.join(f'{_n(px)},{_n(py)}' for px,py in points), fill='none', stroke=colors[j], stroke_width=2)
|
||
for px,py in points:
|
||
_node(fallback, 'circle', cx=px, cy=py, r=4, fill=colors[j])
|
||
metadata.text = json.dumps(payload, ensure_ascii=False, allow_nan=False, separators=(',', ':'))
|
||
runtime = Path(__file__).resolve().parent.parent / 'runtime/ppt-master/scripts'
|
||
if str(runtime) not in sys.path:
|
||
sys.path.insert(0, str(runtime))
|
||
from pptx_shapes import NATIVE_FALLBACK_SHA256_ATTR, svg_native_fallback_fingerprint
|
||
marker.set(NATIVE_FALLBACK_SHA256_ATTR, svg_native_fallback_fingerprint(marker))
|
||
return outer
|
||
|
||
|
||
def _json(path):
|
||
def pairs(items):
|
||
result = {}
|
||
for key, value in items:
|
||
require(key not in result, f'duplicate JSON key: {key}')
|
||
result[key] = value
|
||
return result
|
||
return json.loads(path.read_text(encoding='utf-8'), object_pairs_hook=pairs,
|
||
parse_constant=lambda token: (_ for _ in ()).throw(ValueError(f'nonfinite JSON value: {token}')))
|
||
|
||
|
||
def main():
|
||
parser = argparse.ArgumentParser(description=__doc__)
|
||
parser.add_argument('--manifest', type=Path, required=True)
|
||
parser.add_argument('--theme', required=True)
|
||
parser.add_argument('--data', type=Path, required=True)
|
||
parser.add_argument('--bounds', type=float, nargs=4, required=True)
|
||
parser.add_argument('--id', required=True)
|
||
parser.add_argument('--output', type=Path, required=True)
|
||
args = parser.parse_args()
|
||
try:
|
||
require(args.manifest.is_absolute(), '--manifest must be absolute')
|
||
manifest = ref.load_manifest(args.manifest)
|
||
args.layout = None;args.mode = None
|
||
selection = ref.export_style(args.manifest, manifest, args)
|
||
component = render_chart(_json(args.data), selection['style'], selection['theme_data'], tuple(args.bounds), args.id)
|
||
require(args.output.suffix.lower() == '.svg', 'output must end in .svg')
|
||
require(not args.output.exists() and not args.output.is_symlink(), 'output already exists')
|
||
require(not any(p.is_symlink() for p in args.output.parents), 'output ancestors cannot be symlinks')
|
||
canvas = selection['style']['canvas']
|
||
root = ET.Element('{' + SVG + '}svg', {'width': str(canvas['width']), 'height': str(canvas['height']), 'viewBox': canvas['viewbox']})
|
||
root.append(component)
|
||
args.output.parent.mkdir(parents=True, exist_ok=True)
|
||
with args.output.open('xb') as stream:
|
||
ET.ElementTree(root).write(stream, encoding='utf-8', xml_declaration=True)
|
||
print(json.dumps({'output': str(args.output), 'type': component.get('data-chart-type'), 'theme': args.theme,
|
||
'verification_scope': 'validated component SVG and native marker; native application rendering unverified'}, ensure_ascii=False))
|
||
return 0
|
||
except (ref.InputError, OSError, ValueError, TypeError, KeyError, ET.ParseError) as error:
|
||
print(json.dumps({'error': str(error)}, ensure_ascii=False), file=sys.stderr)
|
||
return 2
|
||
|
||
|
||
if __name__ == '__main__':
|
||
raise SystemExit(main())
|