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