diff --git a/docs/f-23f/new_export_methods.ipynb b/docs/f-23f/new_export_methods.ipynb new file mode 100644 index 00000000000..c61cce60645 --- /dev/null +++ b/docs/f-23f/new_export_methods.ipynb @@ -0,0 +1,654 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "employed-rebate", + "metadata": {}, + "source": [ + "# Export Methods of `ggplot()` and `gggrid()`\n", + "\n", + "Use methods `to_svg()`, `to_html()`,`to_png()`,`to_pdf()` to export plots in file-like objects or on disc.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "arranged-meter", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import io\n", + "import os\n", + "from IPython import display\n", + "from lets_plot import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c38745bd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "LetsPlot.setup_html()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "remarkable-toolbox", + "metadata": {}, + "outputs": [], + "source": [ + "data = {'x': np.random.normal(size=100)}\n", + "p1 = ggplot(data, aes(x='x')) + geom_histogram()" + ] + }, + { + "cell_type": "markdown", + "id": "8c3b3b37", + "metadata": {}, + "source": [ + "#### Export to a file-like object\n", + "When `path` is a file-like object, the data is exported to it by calling its write() method.\n", + "Below is how you can write SVG data into a file-like object without saving it to a file, and use it for display or anything else." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "faced-integral", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -2.0\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -1.5\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -1.0\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -0.5\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 0.0\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 0.5\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 1.0\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 1.5\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 2.0\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 2.5\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 2\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 4\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 6\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 8\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 10\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 12\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " count\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " x\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "file_like = io.BytesIO()\n", + "p1.to_svg(file_like)\n", + "display.SVG(file_like.getvalue())" + ] + }, + { + "cell_type": "markdown", + "id": "6280b266", + "metadata": {}, + "source": [ + "#### Export binary data in PNG or PDF format to a file-like object" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0de51f34", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "file_like = io.BytesIO()\n", + "p1.to_png(file_like, scale = 1.0)" + ] + }, + { + "cell_type": "markdown", + "id": "b8aadbde", + "metadata": {}, + "source": [ + "#### Export to a file" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7b0fdb65", + "metadata": {}, + "outputs": [], + "source": [ + "output_path = p1.to_html('new_folder/plot.html')\n", + "#output_path contains the path of exported file" + ] + }, + { + "cell_type": "markdown", + "id": "8d863635", + "metadata": {}, + "source": [ + "#### Export `gggrid()` to a file-like object" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9a77dc46", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n = 100\n", + "x2 = np.arange(n)\n", + "y2 = np.random.normal(size=n)\n", + "\n", + "file_like = io.BytesIO()\n", + "p2 = ggplot({'x': x2, 'y': y2}, aes(x='x', y='y'))\n", + "gggrid([p2 + geom_point(), p2 + geom_line()]).to_png(file_like)\n", + "display.Image(file_like.getvalue())" + ] + }, + { + "cell_type": "markdown", + "id": "d3e3fef9", + "metadata": {}, + "source": [ + "#### Export gggrid() to a file" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "135b5a28", + "metadata": {}, + "outputs": [], + "source": [ + "output_path = gggrid([p2 + geom_point(), p2 + geom_line()]).to_pdf('grid.pdf')\n", + "#output_path contains the path of exported file" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/future_changes.md b/future_changes.md index 5665368097a..83ae3dcabe6 100644 --- a/future_changes.md +++ b/future_changes.md @@ -37,6 +37,7 @@ - geom_livemap: freeze at zoom 10 [[#892](https://github.com/JetBrains/lets-plot/issues/892)]. - Enormous CPU / Time/ Memory consumption on some data [[#932](https://github.com/JetBrains/lets-plot/issues/932)]. - scale_x_log2(), scale_y_log2() as a shortcut for trans='log2' [[#922](https://github.com/JetBrains/lets-plot/issues/922)]. +- export functions to export to a file-like object [[#885](https://github.com/JetBrains/lets-plot/issues/885)]. - How to calculate proportion of points with same coordinate [[#936](https://github.com/JetBrains/lets-plot/issues/936)]. - gggrid: composite plot is not visible if saved with ggsave [[#942](https://github.com/JetBrains/lets-plot/issues/942)]. - Make scale's 'breaks' / 'labels' parameters understand dict of breaks as keys and labels as values [[#169](https://github.com/JetBrains/lets-plot/issues/169)]. diff --git a/python-package/lets_plot/export/ggsave_.py b/python-package/lets_plot/export/ggsave_.py index 8c1b7b8f1dd..98cd17aeb6c 100644 --- a/python-package/lets_plot/export/ggsave_.py +++ b/python-package/lets_plot/export/ggsave_.py @@ -5,7 +5,7 @@ from os.path import join from typing import Union -from .simple import export_svg, export_html, export_png, export_pdf +from ..plot.core import _to_svg, _to_html, _export_as_raster from ..plot.core import PlotSpec from ..plot.plot import GGBunch from ..plot.subplots import SupPlotsSpec @@ -74,20 +74,17 @@ def ggsave(plot: Union[PlotSpec, SupPlotsSpec, GGBunch], filename: str, *, path: if not path: path = join(os.getcwd(), _DEF_EXPORT_DIR) - if not os.path.exists(path): - os.makedirs(path) - pathname = join(path, filename) ext = ext[1:].lower() if ext == 'svg': - return export_svg(plot, pathname) + return _to_svg(plot, pathname) elif ext in ['html', 'htm']: - return export_html(plot, pathname, iframe=iframe) + return _to_html(plot, pathname, iframe=iframe) elif ext == 'png': - return export_png(plot, pathname, scale) + return _export_as_raster(plot, pathname, scale, 'png') elif ext == 'pdf': - return export_pdf(plot, pathname, scale) + return _export_as_raster(plot, pathname, scale, 'pdf') else: raise ValueError( "Unsupported file extension: '{}'\nPlease use one of: 'png', 'svg', 'pdf', 'html', 'htm'".format(ext) diff --git a/python-package/lets_plot/export/simple.py b/python-package/lets_plot/export/simple.py deleted file mode 100644 index 501a631356a..00000000000 --- a/python-package/lets_plot/export/simple.py +++ /dev/null @@ -1,168 +0,0 @@ -# Copyright (c) 2020. JetBrains s.r.o. -# Use of this source code is governed by the MIT license that can be found in the LICENSE file. - -import io -from os.path import abspath -from typing import Union - -from ..plot.core import PlotSpec -from ..plot.plot import GGBunch -from ..plot.subplots import SupPlotsSpec - - -def export_svg(plot: Union[PlotSpec, SupPlotsSpec, GGBunch], filename: str) -> str: - """ - Export plot or `bunch` to a file in SVG format. - - Parameters - ---------- - plot : `PlotSpec` or `SupPlotsSpec` or `GGBunch` - Plot specification to export. - filename : str - Filename to save SVG under. - - Returns - ------- - str - Absolute pathname of created SVG file. - - """ - if not (isinstance(plot, PlotSpec) or isinstance(plot, SupPlotsSpec) or isinstance(plot, GGBunch)): - raise ValueError("PlotSpec, SupPlotsSpec or GGBunch expected but was: {}".format(type(plot))) - - from .. import _kbridge as kbr - - svg = kbr._generate_svg(plot.as_dict()) - with io.open(filename, mode="w", encoding="utf-8") as f: - f.write(svg) - - return abspath(filename) - - -def export_html(plot: Union[PlotSpec, SupPlotsSpec, GGBunch], filename: str, iframe: bool = False) -> str: - """ - Export plot or `bunch` to a file in HTML format. - - Parameters - ---------- - plot : `PlotSpec` or `SupPlotsSpec` or `GGBunch` - Plot specification to export. - filename : str - Filename to save HTML page under. - iframe : bool, default=False - Whether to wrap HTML page into a iFrame. - - Returns - ------- - str - Absolute pathname of created HTML file. - - """ - if not (isinstance(plot, PlotSpec) or isinstance(plot, SupPlotsSpec) or isinstance(plot, GGBunch)): - raise ValueError("PlotSpec, SupPlotsSpec or GGBunch expected but was: {}".format(type(plot))) - - from .. import _kbridge as kbr - - html_page = kbr._generate_static_html_page(plot.as_dict(), iframe) - with io.open(filename, mode="w", encoding="utf-8") as f: - f.write(html_page) - - return abspath(filename) - - -def export_png(plot: Union[PlotSpec, SupPlotsSpec, GGBunch], filename: str, scale: float = 2.0) -> str: - """ - Export plot or `bunch` to a file in PNG format. - - Parameters - ---------- - plot : `PlotSpec` or `SupPlotsSpec` or `GGBunch` - Plot specification to export. - filename : str - Filename to save PNG under. - scale : float, default=2.0 - Scaling factor for raster output. - - Returns - ------- - str - Absolute pathname of created PNG file. - - Notes - ----- - Export to PNG file uses the CairoSVG library. - CairoSVG is free and distributed under the LGPL-3.0 license. - For more details visit: https://cairosvg.org/documentation/ - - """ - if not (isinstance(plot, PlotSpec) or isinstance(plot, SupPlotsSpec) or isinstance(plot, GGBunch)): - raise ValueError("PlotSpec, SupPlotsSpec or GGBunch expected but was: {}".format(type(plot))) - - try: - import cairosvg - - - except ImportError: - import sys - print("\n" - "To export Lets-Plot figure to a PNG file please install CairoSVG library to your Python environment.\n" - "CairoSVG is free and distributed under the LGPL-3.0 license.\n" - "For more details visit: https://cairosvg.org/documentation/\n", file=sys.stderr) - return None - - from .. import _kbridge - # Use SVG image-rendering style as Cairo doesn't support CSS image-rendering style, - svg = _kbridge._generate_svg(plot.as_dict(), use_css_pixelated_image_rendering=False) - - cairosvg.svg2png(bytestring=svg, write_to=filename, scale=scale) - - return abspath(filename) - - -def export_pdf(plot: Union[PlotSpec, SupPlotsSpec, GGBunch], filename: str, scale: float = 2.0) -> str: - """ - Export plot or `bunch` to a file in PDF format. - - Parameters - ---------- - plot : `PlotSpec` or `SupPlotsSpec` or `GGBunch` - Plot specification to export. - filename : str - Filename to save PDF under. - scale : float, default=2.0 - Scaling factor for raster output. - - Returns - ------- - str - Absolute pathname of created PDF file. - - Notes - ----- - Export to PDF file uses the CairoSVG library. - CairoSVG is free and distributed under the LGPL-3.0 license. - For more details visit: https://cairosvg.org/documentation/ - - """ - if not (isinstance(plot, PlotSpec) or isinstance(plot, SupPlotsSpec) or isinstance(plot, GGBunch)): - raise ValueError("PlotSpec, SupPlotsSpec or GGBunch expected but was: {}".format(type(plot))) - - try: - import cairosvg - - - except ImportError: - import sys - print("\n" - "To export Lets-Plot figure to a PDF file please install CairoSVG library to your Python environment.\n" - "CairoSVG is free and distributed under the LGPL-3.0 license.\n" - "For more details visit: https://cairosvg.org/documentation/\n", file=sys.stderr) - return None - - from .. import _kbridge - # Use SVG image-rendering style as Cairo doesn't support CSS image-rendering style, - svg = _kbridge._generate_svg(plot.as_dict(), use_css_pixelated_image_rendering=False) - - cairosvg.svg2pdf(bytestring=svg, write_to=filename, scale=scale) - - return abspath(filename) diff --git a/python-package/lets_plot/plot/core.py b/python-package/lets_plot/plot/core.py index 120bbda6523..197bac0ed7f 100644 --- a/python-package/lets_plot/plot/core.py +++ b/python-package/lets_plot/plot/core.py @@ -2,7 +2,9 @@ # Copyright (c) 2019. JetBrains s.r.o. # Use of this source code is governed by the MIT license that can be found in the LICENSE file. # +import io import json +import os __all__ = ['aes', 'layer'] @@ -473,6 +475,173 @@ def show(self): from ..frontend_context._configuration import _display_plot _display_plot(self) + def to_svg(self, path) -> str: + """ + Export a plot to a file or to a file-like object in SVG format. + + Parameters + ---------- + self : `PlotSpec` + Plot specification to export. + path : str, file-like object + Сan be either a string specifying a file path or a file-like object. + If a string is provided, the result will be exported to the file at that path. + If a file-like object is provided, the result will be exported to that object. + + Returns + ------- + str + Absolute pathname of created file or None if file-like object is provided. + + Examples + -------- + .. jupyter-execute:: + :linenos: + :emphasize-lines: 9 + + import numpy as np + import io + from lets_plot import * + from IPython import display + LetsPlot.setup_html() + x = np.random.randint(10, size=100) + p = ggplot({'x': x}, aes(x='x')) + geom_bar() + file_like = io.BytesIO() + p.to_svg(file_like) + display.SVG(file_like.getvalue()) + """ + return _to_svg(self, path) + + def to_html(self, path, iframe: bool = None) -> str: + """ + Export a plot to a file or to a file-like object in HTML format. + + Parameters + ---------- + self : `PlotSpec` + Plot specification to export. + path : str, file-like object + Сan be either a string specifying a file path or a file-like object. + If a string is provided, the result will be exported to the file at that path. + If a file-like object is provided, the result will be exported to that object. + iframe : bool, default=False + Whether to wrap HTML page into a iFrame. + + Returns + ------- + str + Absolute pathname of created file or None if file-like object is provided. + + Examples + -------- + .. jupyter-execute:: + :linenos: + :emphasize-lines: 8 + + import numpy as np + import io + from lets_plot import * + LetsPlot.setup_html() + x = np.random.randint(10, size=100) + p = ggplot({'x': x}, aes(x='x')) + geom_bar() + file_like = io.BytesIO() + p.to_html(file_like) + """ + return _to_html(self, path, iframe) + + def to_png(self, path, scale: float = None) -> str: + """ + Export a plot to a file or to a file-like object in PNG format. + + Parameters + ---------- + self : `PlotSpec` + Plot specification to export. + path : str, file-like object + Сan be either a string specifying a file path or a file-like object. + If a string is provided, the result will be exported to the file at that path. + If a file-like object is provided, the result will be exported to that object. + scale : float + Scaling factor for raster output. Default value is 2.0. + + Returns + ------- + str + Absolute pathname of created file or None if file-like object is provided. + + Notes + ----- + Export to PNG file uses the CairoSVG library. + CairoSVG is free and distributed under the LGPL-3.0 license. + For more details visit: https://cairosvg.org/documentation/ + + Examples + -------- + .. jupyter-execute:: + :linenos: + :emphasize-lines: 9 + + import numpy as np + import io + from lets_plot import * + from IPython import display + LetsPlot.setup_html() + x = np.random.randint(10, size=100) + p = ggplot({'x': x}, aes(x='x')) + geom_bar() + file_like = io.BytesIO() + p.to_png(file_like) + display.Image(file_like.getvalue()) + """ + return _export_as_raster(self, path, scale, 'png') + + def to_pdf(self, path, scale: float = None) -> str: + """ + Export a plot to a file or to a file-like object in PDF format. + + Parameters + ---------- + self : `PlotSpec` + Plot specification to export. + path : str, file-like object + Сan be either a string specifying a file path or a file-like object. + If a string is provided, the result will be exported to the file at that path. + If a file-like object is provided, the result will be exported to that object. + scale : float + Scaling factor for raster output. Default value is 2.0. + + Returns + ------- + str + Absolute pathname of created file or None if file-like object is provided. + + Notes + ----- + Export to PDF file uses the CairoSVG library. + CairoSVG is free and distributed under the LGPL-3.0 license. + For more details visit: https://cairosvg.org/documentation/ + + Examples + -------- + .. jupyter-execute:: + :linenos: + :emphasize-lines: 13 + + import numpy as np + import io + import os + from lets_plot import * + from IPython import display + LetsPlot.setup_html() + n = 60 + np.random.seed(42) + x = np.random.choice(list('abcde'), size=n) + y = np.random.normal(size=n) + p = ggplot({'x': x, 'y': y}, aes(x='x', y='y')) + geom_jitter() + file_like = io.BytesIO() + p.to_pdf(file_like) + """ + return _export_as_raster(self, path, scale, 'pdf') + class LayerSpec(FeatureSpec): """ @@ -621,3 +790,78 @@ def _theme_dicts_merge(x, y): overlapping_keys = x.keys() & y.keys() z = {k: {**x[k], **y[k]} for k in overlapping_keys if type(x[k]) is dict and type(y[k]) is dict} return {**x, **y, **z} + + +def _to_svg(spec, path) -> str | None: + from .. import _kbridge as kbr + + svg = kbr._generate_svg(spec.as_dict()) + if isinstance(path, str): + abspath = _makedirs(path) + with io.open(abspath, mode="w", encoding="utf-8") as f: + f.write(svg) + return abspath + else: + path.write(svg.encode()) + return None + + +def _to_html(spec, path, iframe: bool) -> str | None: + if iframe is None: + iframe = False + + from .. import _kbridge as kbr + html_page = kbr._generate_static_html_page(spec.as_dict(), iframe) + + if isinstance(path, str): + abspath = _makedirs(path) + with io.open(abspath, mode="w", encoding="utf-8") as f: + f.write(html_page) + return abspath + else: + path.write(html_page.encode()) + return None + + +def _export_as_raster(spec, path, scale: float, export_format: str) -> str | None: + if scale is None: + scale = 2.0 + + try: + import cairosvg + except ImportError: + import sys + print("\n" + "To export Lets-Plot figure to a PNG or PDF file please install CairoSVG library" + "to your Python environment.\n" + "CairoSVG is free and distributed under the LGPL-3.0 license.\n" + "For more details visit: https://cairosvg.org/documentation/\n", file=sys.stderr) + return None + + if export_format.lower() == 'png': + export_function = cairosvg.svg2png + elif export_format.lower() == 'pdf': + export_function = cairosvg.svg2pdf + else: + raise ValueError("Unknown export format: {}".format(export_format)) + + from .. import _kbridge + # Use SVG image-rendering style as Cairo doesn't support CSS image-rendering style, + svg = _kbridge._generate_svg(spec.as_dict(), use_css_pixelated_image_rendering=False) + + if isinstance(path, str): + abspath = _makedirs(path) + result = abspath + else: + result = None # file-like object is provided. No path to return. + export_function(bytestring=svg, write_to=path, scale=scale) + return result + + +def _makedirs(path: str) -> str: + """Return absolute path to a file after creating all directories in the path.""" + abspath = os.path.abspath(path) + dirname = os.path.dirname(abspath) + if dirname and not os.path.exists(dirname): + os.makedirs(dirname) + return abspath diff --git a/python-package/lets_plot/plot/subplots.py b/python-package/lets_plot/plot/subplots.py index c84492cb9a0..db4f40ecfb0 100644 --- a/python-package/lets_plot/plot/subplots.py +++ b/python-package/lets_plot/plot/subplots.py @@ -11,6 +11,7 @@ from lets_plot.plot.core import FeatureSpecArray from lets_plot.plot.core import _specs_to_dict from lets_plot.plot.core import _theme_dicts_merge +from lets_plot.plot.core import _to_svg, _to_html, _export_as_raster __all__ = ['SupPlotsSpec'] @@ -113,3 +114,181 @@ def show(self): """ from ..frontend_context._configuration import _display_plot _display_plot(self) + + def to_svg(self, path) -> str: + """ + Export all plots currently in this 'bunch' to a file or file-like object in SVG format. + + Parameters + ---------- + self : `SupPlotsSpec` + Subplots specification to export. + path : str, file-like object + Сan be either a string specifying a file path or a file-like object. + If a string is provided, the result will be exported to the file at that path. + If a file-like object is provided, the result will be exported to that object. + + Returns + ------- + str + Absolute pathname of created file or None if file-like object is provided. + + Examples + -------- + .. jupyter-execute:: + :linenos: + :emphasize-lines: 13 + + import numpy as np + import io + import os + from lets_plot import * + from IPython import display + LetsPlot.setup_html() + n = 60 + np.random.seed(42) + x = np.random.choice(list('abcde'), size=n) + y = np.random.normal(size=n) + p = ggplot({'x': x, 'y': y}, aes(x='x', y='y')) + geom_jitter() + file_like = io.BytesIO() + p.to_svg(file_like) + display.SVG(file_like.getvalue()) + """ + return _to_svg(self, path) + + def to_html(self, path, iframe: bool = None) -> str: + """ + Export all plots currently in this 'bunch' to a file or file-like object in HTML format. + + Parameters + ---------- + self : `SupPlotsSpec` + Subplots specification to export. + path : str, file-like object + Сan be either a string specifying a file path or a file-like object. + If a string is provided, the result will be exported to the file at that path. + If a file-like object is provided, the result will be exported to that object. + iframe : bool, default=False + Whether to wrap HTML page into a iFrame. + + Returns + ------- + str + Absolute pathname of created file or None if file-like object is provided. + + Examples + -------- + .. jupyter-execute:: + :linenos: + :emphasize-lines: 12 + + import numpy as np + import io + import os + from lets_plot import * + LetsPlot.setup_html() + n = 60 + np.random.seed(42) + x = np.random.choice(list('abcde'), size=n) + y = np.random.normal(size=n) + p = ggplot({'x': x, 'y': y}, aes(x='x', y='y')) + geom_jitter() + file_like = io.BytesIO() + p.to_html(file_like) + """ + return _to_html(self, path, iframe) + + def to_png(self, path, scale=None) -> str: + """ + Export all plots currently in this 'bunch' to a file or file-like object in PNG format. + + Parameters + ---------- + self : `SupPlotsSpec` + Subplots specification to export. + path : str, file-like object + Сan be either a string specifying a file path or a file-like object. + If a string is provided, the result will be exported to the file at that path. + If a file-like object is provided, the result will be exported to that object. + scale : float + Scaling factor for raster output. Default value is 2.0. + + Returns + ------- + str + Absolute pathname of created file or None if file-like object is provided. + + Notes + ----- + Export to PNG file uses the CairoSVG library. + CairoSVG is free and distributed under the LGPL-3.0 license. + For more details visit: https://cairosvg.org/documentation/ + + Examples + -------- + .. jupyter-execute:: + :linenos: + :emphasize-lines: 13 + + import numpy as np + import io + import os + from lets_plot import * + from IPython import display + LetsPlot.setup_html() + n = 60 + np.random.seed(42) + x = np.random.choice(list('abcde'), size=n) + y = np.random.normal(size=n) + p = ggplot({'x': x, 'y': y}, aes(x='x', y='y')) + geom_jitter() + file_like = io.BytesIO() + p.to_png(file_like) + display.Image(file_like.getvalue()) + """ + return _export_as_raster(self, path, scale, 'png') + + def to_pdf(self, path, scale=None) -> str: + """ + Export all plots currently in this 'bunch' to a file or file-like object in PDF format. + + Parameters + ---------- + self : `SupPlotsSpec` + Subplots specification to export. + path : str, file-like object + Сan be either a string specifying a file path or a file-like object. + If a string is provided, the result will be exported to the file at that path. + If a file-like object is provided, the result will be exported to that object. + scale : float + Scaling factor for raster output. Default value is 2.0. + + Returns + ------- + str + Absolute pathname of created file or None if file-like object is provided. + + Notes + ----- + Export to PDF file uses the CairoSVG library. + CairoSVG is free and distributed under the LGPL-3.0 license. + For more details visit: https://cairosvg.org/documentation/ + + Examples + -------- + .. jupyter-execute:: + :linenos: + :emphasize-lines: 12 + + import numpy as np + import io + import os + from lets_plot import * + LetsPlot.setup_html() + n = 60 + np.random.seed(42) + x = np.random.choice(list('abcde'), size=n) + y = np.random.normal(size=n) + p = ggplot({'x': x, 'y': y}, aes(x='x', y='y')) + geom_jitter() + file_like = io.BytesIO() + p.to_pdf(file_like) + """ + return _export_as_raster(self, path, scale, 'pdf')