def test_fmt_mimetype_error() -> None:
with pytest.raises(ValueError) as err:
fmt_to_mimetype("bad-fmt")
assert "Unrecognized fmt='bad-fmt'" in str(err.value)
with pytest.raises(ValueError) as err:
mimetype_to_fmt("bad-mimetype")
assert "Unrecognized mimetype='bad-mimetype'" in str(err.value)
def test_infer_mode(spec: JSONDict) -> None:
mimetype, vg_spec = render(spec, "vega").popitem()
assert mimetype == fmt_to_mimetype("vega")
mimetype, vl_svg = render(spec, "svg").popitem()
assert mimetype == fmt_to_mimetype("svg")
mimetype, vg_svg = render(vg_spec, "svg").popitem()
assert mimetype == fmt_to_mimetype("svg")
assert vl_svg == vg_svg
def test_node_mimebundle(name: str, data: Any, mode: str, fmt: str) -> None:
saver = NodeSaver(data[mode], mode=mode)
mimetype, out = saver.mimebundle(fmt).popitem()
assert mimetype == fmt_to_mimetype(fmt)
if fmt == "png":
assert isinstance(out, bytes)
im = Image.open(io.BytesIO(out))
assert im.format == "PNG"
im_expected = Image.open(io.BytesIO(data[fmt]))
assert abs(im.size[0] - im_expected.size[0]) < 5
assert abs(im.size[1] - im_expected.size[1]) < 5
elif fmt == "pdf":
assert isinstance(out, bytes)
pdf = PdfFileReader(io.BytesIO(out))
box = pdf.getPage(0).mediaBox
pdf_expected = PdfFileReader(io.BytesIO(data[fmt]))
box_expected = pdf_expected.getPage(0).mediaBox
assert abs(box.getWidth() - box_expected.getWidth()) < 5
assert abs(box.getHeight() - box_expected.getHeight()) < 5
elif fmt == "svg":
assert isinstance(out, str)
assert out.startswith("<svg")
else:
assert out == data[fmt]
def test_selenium_mimebundle(
name: str,
data: Dict[str, Any],
mode: str,
fmt: str,
offline: bool,
internet_ok: bool,
) -> None:
if not (offline or internet_ok):
pytest.xfail("Internet not available")
saver = SeleniumSaver(data[mode], mode=mode, offline=offline)
if mode == "vega" and fmt == "vega-lite":
with pytest.raises(ValueError):
saver.mimebundle(fmt)
return
mimetype, out = saver.mimebundle(fmt).popitem()
assert mimetype == fmt_to_mimetype(fmt)
if fmt == "png":
assert isinstance(out, bytes)
im = Image.open(io.BytesIO(out))
assert im.format == "PNG"
im_expected = Image.open(io.BytesIO(data[fmt]))
assert abs(im.size[0] - im_expected.size[0]) < 5
assert abs(im.size[1] - im_expected.size[1]) < 5
elif fmt == "svg":
assert out == data[fmt]
else:
assert out == data[fmt]
def test_node_mimebundle(name: str, data: Any, mode: str, fmt: str,
vega_cli_options: Optional[List[str]]) -> None:
saver = NodeSaver(data[mode], mode=mode, vega_cli_options=vega_cli_options)
mimetype, out = saver.mimebundle(fmt).popitem()
assert mimetype == fmt_to_mimetype(fmt)
if fmt == "png":
assert isinstance(out, bytes)
im = Image.open(io.BytesIO(out))
assert im.format == "PNG"
im_expected = Image.open(io.BytesIO(data[fmt]))
assert abs(im.size[0] - im_expected.size[0]) < 5
assert abs(im.size[1] - im_expected.size[1]) < 5
elif fmt == "pdf":
assert isinstance(out, bytes)
pdf = PdfFileReader(io.BytesIO(out))
box = pdf.getPage(0).mediaBox
pdf_expected = PdfFileReader(io.BytesIO(data[fmt]))
box_expected = pdf_expected.getPage(0).mediaBox
assert abs(box.getWidth() - box_expected.getWidth()) < 5
assert abs(box.getHeight() - box_expected.getHeight()) < 5
elif fmt == "svg":
assert isinstance(out, str)
im = SVGImage(out)
im_expected = SVGImage(data[fmt])
assert abs(im.width - im_expected.width) < 5
assert abs(im.height - im_expected.height) < 5
else:
assert out == data[fmt]
def _mimebundle(self, fmt: str) -> Mimebundle:
if fmt not in self.valid_formats:
raise ValueError(
f"Invalid format: {fmt!r}. Must be one of {self.valid_formats}"
)
if self._inline:
html = INLINE_HTML_TEMPLATE.format(
spec=json.dumps(self._spec),
embed_opt=json.dumps(self._embed_opt),
vega_version=self._package_versions["vega"],
vegalite_version=self._package_versions["vega-lite"],
vegaembed_version=self._package_versions["vega-embed"],
vega_script=get_bundled_script("vega",
self._package_versions["vega"]),
vegalite_script=get_bundled_script(
"vega-lite", self._package_versions["vega-lite"]),
vegaembed_script=get_bundled_script(
"vega-embed", self._package_versions["vega-embed"]),
)
else:
html = HTML_TEMPLATE.format(
spec=json.dumps(self._spec),
embed_opt=json.dumps(self._embed_opt),
vega_url=self._package_url("vega"),
vegalite_url=self._package_url("vega-lite"),
vegaembed_url=self._package_url("vega-embed"),
)
return {fmt_to_mimetype("html"): html}
def mimebundle(self, fmts: Union[str, Iterable[str]]) -> Mimebundle:
"""Return a mimebundle representation of the chart.
Parameters
----------
fmts : list of strings
A list of formats to include in the results.
Returns
-------
mimebundle : dict
The chart's mimebundle representation.
"""
if isinstance(fmts, str):
fmts = [fmts]
bundle: Mimebundle = {}
for fmt in fmts:
if fmt not in self.valid_formats[self._mode]:
raise ValueError(
f"invalid fmt={fmt!r}; must be one of {self.valid_formats[self._mode]}."
)
mimetype = fmt_to_mimetype(
fmt,
vega_version=self._package_versions["vega"],
vegalite_version=self._package_versions["vega-lite"],
)
bundle[mimetype] = self._serialize(fmt, "mimebundle")
return bundle
def _mimebundle(self, fmt: str) -> Mimebundle:
out = self._extract(fmt)
mimetype = fmt_to_mimetype(
fmt,
vega_version=self._vega_version,
vegalite_version=self._vegalite_version,
)
if fmt == "png":
assert isinstance(out, str)
assert out.startswith("data:image/png;base64,")
return {mimetype: base64.b64decode(out.split(",", 1)[1].encode())}
elif fmt == "svg":
assert isinstance(out, str)
return {mimetype: out}
elif fmt == "vega":
assert isinstance(out, dict)
return {mimetype: out}
else:
raise ValueError(f"Unrecognized format: {fmt}")
def _mimebundle(self, fmt: str) -> Mimebundle:
"""Return a mimebundle with a single mimetype."""
if self._mode not in ["vega", "vega-lite"]:
raise ValueError("mode must be either 'vega' or 'vega-lite'")
spec = self._spec
mimetype = fmt_to_mimetype(fmt)
if self._mode == "vega-lite":
spec = vl2vg(spec)
if fmt == "vega":
return {mimetype: spec}
elif fmt == "png":
return {mimetype: vg2png(spec)}
elif fmt == "svg":
return {mimetype: vg2svg(spec)}
elif fmt == "pdf":
return {mimetype: vg2pdf(spec)}
else:
raise ValueError(f"Unrecognized format: {fmt}")
def _mimebundle(self, fmt: str) -> Mimebundle:
if self._mode == "vega":
raise ValueError("Cannot save vega spec as vega-lite.")
return {fmt_to_mimetype("vega-lite"): self._spec}
def test_fmt_mimetype(fmt: str) -> None:
mimetype = fmt_to_mimetype(fmt)
fmt_out = mimetype_to_fmt(mimetype)
assert fmt == fmt_out