lets-plot 4.8.0rc1__cp313-cp313-macosx_12_0_arm64.whl

lets_plot/export/ggsave_.py

@@ -0,0 +1,170 @@
+#  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 os
+from os.path import join
+from typing import Union, Optional
+
+from ..plot.core import PlotSpec
+from ..plot.core import _to_svg, _to_html, _export_as_raster
+from ..plot.plot import GGBunch
+from ..plot.subplots import SupPlotsSpec
+
+__all__ = ['ggsave']
+
+_DEF_EXPORT_DIR = "lets-plot-images"
+
+
+def ggsave(plot: Union[PlotSpec, SupPlotsSpec, GGBunch], filename: str, *, path: str = None, iframe: bool = True,
+           scale: float = None, w: Optional[float] = None, h: Optional[float] = None, unit: Optional[str] = None,
+           dpi: Optional[int] = None) -> str:
+    """
+    Export plot to a file.
+    Supported formats: PNG, SVG, PDF, HTML.
+
+    The exported file is created in the directory ${user.dir}/lets-plot-images
+    if not specified otherwise (see the ``path`` parameter).
+
+    Parameters
+    ----------
+    plot : ``PlotSpec``
+        Plot specification to export.
+    filename : str
+        Name of the file. It must end with a file extension corresponding
+        to one of the supported formats: SVG, HTML (or HTM), PNG, PDF (requires the pillow library).
+    path : str
+        Path to a directory to save image files in.
+        By default, it is ${user.dir}/lets-plot-images.
+    iframe : bool, default=True
+        Whether to wrap the HTML page into an iFrame.
+        Only applicable when exporting to HTML.
+        Some browsers may not display some UTF-8 characters correctly when setting iframe=True
+    scale : float, default=2.0
+        Scaling factor for raster output.
+        Only applicable when exporting to PNG or PDF.
+    w : float, default=None
+        Width of the output image in units.
+        Only applicable when exporting to SVG, PNG, or PDF.
+    h : float, default=None
+        Height of the output image in units.
+        Only applicable when exporting to SVG, PNG, or PDF.
+    unit : {'in', 'cm', 'mm', 'px'}, default='in'
+        Unit of the output image. One of: 'in', 'cm', 'mm' or 'px'.
+        Only applicable when exporting to SVG, PNG, or PDF.
+    dpi : int, default=300
+        Resolution in dots per inch.
+        Only applicable when exporting to PNG or PDF.
+        The default value depends on the unit:
+
+        - for 'px' it is 96 (output image will have the same pixel size as ``w``, and ``h`` values)
+        - for physical units ('in', 'cm', 'mm') it is 300.
+
+    Returns
+    -------
+    str
+        Absolute pathname of the created file.
+
+    Notes
+    -----
+    Large plot dimensions without units require explicit unit specification.
+    When ``w`` or ``h`` value exceeds 20 without specifying units (e.g., ``ggsave(p, 300, 400)``),
+    we ask to specify units explicitly:
+    ``ggsave(p, 300, 400, unit='px')`` or ``ggsave(p, 3, 4, unit='in')``.
+
+    ----
+
+    The output format is inferred from the filename extension.
+
+    For PNG, and PDF formats:
+
+    - If ``w``, ``h``, ``unit``, and ``dpi`` are all specified:
+
+      - The plot's pixel size (default or set by `ggsize() <https://lets-plot.org/python/pages/api/lets_plot.ggsize.html>`__) is ignored.
+      - The output size is calculated using the specified ``w``, ``h``, ``unit`` and ``dpi``.
+
+        - The plot is resized to fit the specified ``w`` x ``h`` area, which may affect the layout, tick labels, and other elements.
+
+    - If only ``dpi`` is specified:
+
+      - The plot's pixel size (default or set by `ggsize() <https://lets-plot.org/python/pages/api/lets_plot.ggsize.html>`__) is converted to inches using the standard display PPI of 96.
+      - The output size is then calculated based on the specified DPI.
+
+        - The plot maintains its aspect ratio, preserving layout, tick labels, and other visual elements.
+        - Useful for printing - the plot will appear nearly the same size as on screen.
+
+    - If ``w``, ``h`` are not specified:
+
+      - The ``scale`` parameter is used to determine the output size.
+
+        - The plot maintains its aspect ratio, preserving layout, tick labels, and other visual elements.
+        - Useful for generating high-resolution images suitable for publication.
+
+    For SVG format:
+
+    - If ``w``, ``h``, and ``unit`` are specified:
+
+      - The plot's pixel size (default or set by `ggsize() <https://lets-plot.org/python/pages/api/lets_plot.ggsize.html>`__) is ignored.
+      - The output size is calculated using the specified ``w``, ``h``, and ``unit``.
+
+    ----
+
+    Plots with ``geom_livemap()`` can be saved to HTML only.
+
+
+    Examples
+    --------
+    .. jupyter-execute::
+        :linenos:
+        :emphasize-lines: 6
+
+        from IPython.display import Image
+        from lets_plot import *
+        LetsPlot.setup_html()
+        filename = 'plot.png'
+        plot = ggplot() + geom_point(x=0, y=0) + ggtitle(filename)
+        fullpath = ggsave(plot, filename, w=4, h=3)
+        Image(filename=fullpath, width=600, height=450)
+
+    |
+
+    .. jupyter-execute::
+        :linenos:
+        :emphasize-lines: 6
+
+        from IPython.display import HTML
+        from lets_plot import *
+        LetsPlot.setup_html()
+        filename = 'plot.html'
+        plot = ggplot() + geom_point(x=0, y=0) + ggtitle(filename)
+        fullpath = ggsave(plot, filename, iframe=False)
+        HTML(filename=fullpath)
+
+    """
+
+    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)))
+
+    filename = filename.strip()
+    name, ext = os.path.splitext(filename)
+
+    if not name:
+        raise ValueError("Malformed filename: '{}'.".format(filename))
+    if not ext:
+        raise ValueError("Missing file extension: '{}'.".format(filename))
+
+    if not path:
+        path = join(os.getcwd(), _DEF_EXPORT_DIR)
+
+    pathname = join(path, filename)
+
+    ext = ext[1:].lower()
+    if ext == 'svg':
+        return _to_svg(plot, pathname, w=w, h=h, unit=unit)
+    elif ext in ['html', 'htm']:
+        return _to_html(plot, pathname, iframe=iframe)
+    elif ext in ['png', 'pdf']:
+        return _export_as_raster(plot, pathname, scale, export_format=ext, w=w, h=h, unit=unit, dpi=dpi)
+    else:
+        raise ValueError(
+            "Unsupported file extension: '{}'\nPlease use one of: 'png', 'svg', 'pdf', 'html', 'htm'".format(ext)
+        )

lets_plot/frontend_context/__init__.py

@@ -0,0 +1,8 @@
+#
+# 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.
+#
+
+from ._configuration import *
+
+__all__ = _configuration.__all__

lets_plot/frontend_context/_configuration.py

@@ -0,0 +1,151 @@
+#
+# 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.
+#
+from typing import Dict, Any
+
+from ._frontend_ctx import FrontendContext
+from ._html_contexts import _create_html_frontend_context, _use_isolated_frame, _create_wb_html_frontend_context
+from ._json_contexts import _create_json_frontend_context, _is_Intellij_Python_Lets_Plot_Plugin
+from ._mime_types import TEXT_HTML, LETS_PLOT_JSON
+from ._static_svg_ctx import StaticSvgImageContext
+from ._webbr_html_page_ctx import WebBrHtmlPageContext
+from .._version import __version__
+from ..plot.core import PlotSpec
+from ..plot.plot import GGBunch
+from ..plot.subplots import SupPlotsSpec
+
+__all__ = []
+
+_frontend_contexts: Dict[str, FrontendContext] = {}
+
+_default_mimetype = TEXT_HTML
+if _is_Intellij_Python_Lets_Plot_Plugin():
+    _default_mimetype = LETS_PLOT_JSON
+    _frontend_contexts[LETS_PLOT_JSON] = _create_json_frontend_context()
+
+
+def _setup_html_context(*,
+                        isolated_frame: bool = None,
+                        offline: bool,
+                        no_js: bool,
+                        show_status: bool) -> None:
+    """
+    Configures Lets-Plot HTML output.
+
+    Parameters
+    ----------
+    isolated_frame : bool
+        True - generate HTLM which can be used in `iframe` or in a standalone HTML document
+        False - pre-load Lets-Plot JS library. Notebook cell output will only consist of HTML for the plot rendering.
+        Default: None - auto-detect.
+    offline : bool
+        True - full Lets-Plot JS bundle will be added to the notebook. Use this option if you would like
+        to work with notebook without the Internet connection.
+        False - load Lets-Plot JS library from CDN.
+    no_js : bool
+        True - do not generate HTML+JS as an output - just static SVG image.
+    show_status : bool
+        Whether to show status of loading of the Lets-Plot JS library.
+        Only applicable when the Lets-Plot JS library is preloaded.
+
+    """
+    global _default_mimetype
+    if _default_mimetype == LETS_PLOT_JSON:
+        # Plots will be rendered by Lets-Plot IntelliJ plugin.
+        # No other contexts are needed.
+        if show_status:
+            print(
+                'Lets-Plot v{}: output mimetype {} configured by default. No need for HTML output.'.format(__version__,
+                                                                                                           LETS_PLOT_JSON))
+        return
+
+    if no_js:
+        ctx = StaticSvgImageContext()
+    else:
+        ctx = _create_html_frontend_context(isolated_frame, offline=offline)
+
+    ctx.configure(verbose=show_status)
+    _frontend_contexts[TEXT_HTML] = ctx
+
+
+def _setup_wb_html_context(*,
+                           exec: str,
+                           new: bool) -> None:
+    """
+    Configures Lets-Plot HTML output for showing in a browser.
+
+    Parameters
+    ----------
+    exec : str, optional
+        Command to execute to open the plot in a web browser.
+        If not specified, the default browser will be used.
+    new : bool, default=False
+        If True, the URL is opened in a new window of the web browser.
+        If False, the URL is opened in the already opened web browser window.
+    """
+    ctx = _create_wb_html_frontend_context(exec, new)
+    _frontend_contexts[TEXT_HTML] = ctx
+
+
+def _display_plot(spec: Any):
+    """
+    Draw plot or `bunch` of plots in the current frontend context
+    :param spec: PlotSpec or GGBunch object
+    """
+    if not (isinstance(spec, PlotSpec) or isinstance(spec, SupPlotsSpec) or isinstance(spec, GGBunch)):
+        raise ValueError("PlotSpec or SupPlotsSpec expected but was: {}".format(type(spec)))
+
+    if _default_mimetype == TEXT_HTML:
+        if TEXT_HTML not in _frontend_contexts:
+            raise RuntimeError(
+                "HTML frontend not configured. Before displaying plots, please call either:\n"
+                "- LetsPlot.setup_html() for displaying HTML output inplace\n"
+                "- LetsPlot.setup_show_ext() for displaying HTML output in an external web browser\n"
+            )
+
+        if isinstance(_frontend_contexts[TEXT_HTML], WebBrHtmlPageContext):
+            _frontend_contexts[TEXT_HTML].show(spec.as_dict())
+            return
+
+        plot_html = _as_html(spec.as_dict())
+        try:
+            from IPython.display import display_html
+            display_html(plot_html, raw=True)
+            return
+        except ImportError:
+            pass
+
+        print(spec.as_dict())
+        return
+
+    if _default_mimetype == LETS_PLOT_JSON:
+        _frontend_contexts[LETS_PLOT_JSON].show(spec.as_dict())
+        return
+
+    # fallback to plain text.
+    print(spec.as_dict())
+
+
+def _as_html(plot_spec: Dict) -> str:
+    """
+    Creates plot HTML using 'html' frontend context.
+
+    :param plot_spec: dict
+    """
+    if TEXT_HTML not in _frontend_contexts:
+        if _use_isolated_frame():
+            # 'Isolated' HTML context can be setup lazily.
+            _setup_html_context(isolated_frame=True,
+                                offline=False,
+                                no_js=False,
+                                show_status=False)
+        else:
+            return """\
+                <div style="color:darkred;">
+                    Lets-plot `html` is not configured.<br> 
+                    Try to use `LetsPlot.setup_html()` before first occurrence of plot.
+                </div>    
+                """
+
+    return _frontend_contexts[TEXT_HTML].as_str(plot_spec)

lets_plot/frontend_context/_frontend_ctx.py

@@ -0,0 +1,16 @@
+#
+# 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.
+#
+from typing import Dict
+
+
+class FrontendContext:
+    def configure(self, verbose: bool):
+        pass
+
+    def as_str(self, plot_spec: Dict) -> str:
+        pass
+
+    def show(self, plot_spec: Dict) -> str:
+        pass

lets_plot/frontend_context/_html_contexts.py

@@ -0,0 +1,117 @@
+#  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 os
+
+from ._frontend_ctx import FrontendContext
+from ._jupyter_notebook_ctx import JupyterNotebookContext
+from ._static_html_page_ctx import StaticHtmlPageContext
+from ._webbr_html_page_ctx import WebBrHtmlPageContext
+from .._global_settings import has_global_value, get_global_bool, HTML_ISOLATED_FRAME
+
+
+def _create_html_frontend_context(isolated_frame: bool = None, offline: bool = None) -> FrontendContext:
+    """
+    Configures Lets-Plot HTML output.
+
+    Parameters
+    ----------
+    isolated_frame : bool, optional, default None - auto-detect
+        If True, generate HTLM which can be used in `iframe` or in a standalone HTML document
+        If False, pre-load Lets-Plot JS library. Notebook cell output will only consist of HTML for the plot rendering.
+
+    offline : bool, optional, default None - evaluated to 'connected' mode in production environment.
+        If True, full Lets-Plot JS bundle will be added to the notebook. Use this option if you would like
+        to work with notebook without the Internet connection.
+        If False, load Lets-Plot JS library from CDN.
+    """
+    if isolated_frame is None:
+        isolated_frame = _use_isolated_frame()
+
+    if isolated_frame:
+        return StaticHtmlPageContext(offline)
+    else:
+        return JupyterNotebookContext(offline)
+
+
+def _create_wb_html_frontend_context(exec: str, new: bool) -> FrontendContext:
+    """
+    Configures Lets-Plot HTML output for showing in web browser.
+
+    Parameters
+    ----------
+    exec : str, optional
+        The name of the web browser to use.
+        If not specified, the default browser will be used.
+    new : bool, default=False
+        If True, the URL is opened in a new window of the web browser.
+        If False, the URL is opened in the already opened web browser window.
+    """
+    return WebBrHtmlPageContext(exec, new)
+
+
+def _use_isolated_frame() -> bool:
+    # check environment
+    if has_global_value(HTML_ISOLATED_FRAME):
+        return get_global_bool(HTML_ISOLATED_FRAME)
+
+    return _detect_isolated_frame()
+
+
+def _detect_isolated_frame() -> bool:
+    if not _is_IPython_display():
+        return True  # isolated HTML page to show somehow
+
+    # Most online notebook platforms are showing cell output in iframe and require
+    # a self-contained HTML which includes both:
+    # - the script loading JS library and
+    # - the script that uses this JS lib to create plot.
+
+    # Try to detect the platform.
+    try:
+        import google.colab
+        return True  # Colab -> iframe
+    except ImportError:
+        pass
+
+    if os.path.exists("/kaggle/input"):
+        return False  # Kaggle -> no iframe
+
+    if "AZURE_NOTEBOOKS_HOST" in os.environ:
+        return True  # Azure Notebook -> iframe
+
+    if "DEEPNOTE_PROJECT_ID" in os.environ:
+        return True  # Deepnote Notebook -> iframe
+
+    if "databricks" in str(os.environ):
+        # Databricks notebook -> iframe
+        # As proposed: https://github.com/JetBrains/lets-plot/issues/602
+        return True
+
+    if "NEXTJOURNAL" in str(os.environ):
+        return True  # NextJournal notebook -> iframe
+
+    if os.getenv("PLOTLY_RENDERER") == "colab":
+        # good enouth - something colab-like
+        return True  # Colab -> iframe
+
+    # ToDo: other platforms: vscode, nteract, cocalc
+
+    try:
+        shell = get_ipython().__class__.__name__
+        if shell == 'ZMQInteractiveShell':
+            return False  # Jupyter notebook or qtconsole  -> load JS librarty once per notebook
+        elif shell == 'TerminalInteractiveShell':
+            return True  # Terminal running IPython  -> an isolated HTML page to show somehow
+        else:
+            return True  # Other type (?)
+    except NameError:
+        return True  # some other env (even standard Python interpreter) ->  an isolated HTML page to show somehow
+
+
+def _is_IPython_display() -> bool:
+    try:
+        from IPython.display import display_html
+        return True
+    except ImportError:
+        return False

lets_plot/frontend_context/_intellij_python_json_ctx.py

@@ -0,0 +1,38 @@
+#
+# 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.
+#
+
+from typing import Dict, Tuple
+
+from ._frontend_ctx import FrontendContext
+from ._mime_types import LETS_PLOT_JSON
+from .._type_utils import standardize_dict
+
+
+class IntellijPythonJsonContext(FrontendContext):
+
+    def configure(self, verbose: bool):
+        pass
+
+    def show(self, plot_spec: Dict) -> str:
+        plot_spec_std = standardize_dict(plot_spec)
+        data_object = DisplayDataObject(plot_spec_std)
+
+        # See intellij.python.helpers module in IDEA
+        from datalore.display import display
+        display(data_object)
+
+
+class DisplayDataObject():
+
+    def __init__(self, plot_spec: Dict) -> None:
+        super().__init__()
+        self.data_object = (LETS_PLOT_JSON, plot_spec)
+
+    def _repr_display_(self) -> Tuple[str, Dict]:
+        """
+        Special method discovered and invoked by datalore.display.display()
+        See: IDEA/community/python/helpers/pycharm_display/datalore/display/display_.py
+        """
+        return self.data_object

lets_plot/frontend_context/_json_contexts.py

@@ -0,0 +1,39 @@
+#  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 os
+
+from ._frontend_ctx import FrontendContext
+from ._intellij_python_json_ctx import IntellijPythonJsonContext
+
+
+def _create_json_frontend_context() -> FrontendContext:
+    """
+    Configures Lets-Plot JSON output.
+
+    Such context requires a Lets-Plot JSON interpreter plugged in to the frontend env (like PyCharm)
+    """
+
+    if _is_Intellij_Python_Lets_Plot_Plugin():
+        return IntellijPythonJsonContext()
+
+    # ToDo: GenericJsonFrontendContext
+    raise RuntimeError("Couldn't detect Intellij Python environment")
+
+
+def _is_Intellij_Python_Lets_Plot_Plugin() -> bool:
+    try:
+        # An empty marker module defined by Intellij Lets-Plot plugin
+        # import lets_plot_intellij_python_plugin  <---- the old way.
+
+
+        # The check above is not working with PyCharm remote interpreter: https://github.com/JetBrains/lets-plot/issues/348
+
+        # 1) The "datalore.display" is present in both PyCharm and Datalore env.
+        #    See `intellij.python.helpers` module in IDEA.
+        from datalore.display import display
+
+        # 2) The "DATALORE_HOME" is only present in Datalore env but not in PyCharm env.
+        return "DATALORE_HOME" not in os.environ
+    except ImportError:
+        return False

lets_plot/frontend_context/_jupyter_notebook_ctx.py

@@ -0,0 +1,119 @@
+#
+# 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 os
+import pkgutil
+import random
+import string
+from typing import Dict
+
+try:
+    from IPython.display import display_html
+except ImportError:
+    display_html = None
+
+from ._frontend_ctx import FrontendContext
+from .. import _kbridge as kbr
+from .._global_settings import get_js_cdn_url
+from .._global_settings import JS_BASE_URL, JS_NAME
+from .._version import __version__
+
+# Data-attributes used to store extra information about the meaning of 'script' elements
+_ATT_SCRIPT_KIND = 'data-lets-plot-script'
+_SCRIPT_KIND_LIB_LOADING = 'library'
+_SCRIPT_KIND_PLOT = 'plot'
+
+
+class JupyterNotebookContext(FrontendContext):
+
+    def __init__(self, offline: bool) -> None:
+        super().__init__()
+        self.connected = not offline
+
+    def configure(self, verbose: bool):
+        if self.connected:
+            # noinspection PyTypeChecker
+            display_html(self._configure_connected_script(verbose), raw=True)
+        else:
+            # noinspection PyTypeChecker
+            display_html(self._configure_embedded_script(verbose), raw=True)
+
+    def as_str(self, plot_spec: Dict) -> str:
+        return kbr._generate_dynamic_display_html(plot_spec)
+
+    @staticmethod
+    def _configure_connected_script(verbose: bool) -> str:
+        url = get_js_cdn_url()
+        output_id = JupyterNotebookContext._rand_string()
+        success_message = """
+            var div = document.createElement("div");
+            div.style.color = 'darkblue';
+            div.textContent = 'Lets-Plot JS successfully loaded.';
+            document.getElementById("{id}").appendChild(div);
+        """.format(id=output_id) if verbose else ""
+
+        return """
+            <div id="{id}"></div>
+            <script type="text/javascript" {data_attr}="{script_kind}">
+                if(!window.letsPlotCallQueue) {{
+                    window.letsPlotCallQueue = [];
+                }}; 
+                window.letsPlotCall = function(f) {{
+                    window.letsPlotCallQueue.push(f);
+                }};
+                (function() {{
+                    var script = document.createElement("script");
+                    script.type = "text/javascript";
+                    script.src = "{url}";
+                    script.onload = function() {{
+                        window.letsPlotCall = function(f) {{f();}};
+                        window.letsPlotCallQueue.forEach(function(f) {{f();}});
+                        window.letsPlotCallQueue = [];
+                        {success_message}
+                    }};
+                    script.onerror = function(event) {{
+                        window.letsPlotCall = function(f) {{}};    // noop
+                        window.letsPlotCallQueue = [];
+                        var div = document.createElement("div");
+                        div.style.color = 'darkred';
+                        div.textContent = 'Error loading Lets-Plot JS';
+                        document.getElementById("{id}").appendChild(div);
+                    }};
+                    var e = document.getElementById("{id}");
+                    e.appendChild(script);
+                }})()
+            </script>
+            """.format(
+            data_attr=_ATT_SCRIPT_KIND,
+            script_kind=_SCRIPT_KIND_LIB_LOADING,
+            id=output_id,
+            url=url,
+            success_message=success_message)
+
+    @staticmethod
+    def _configure_embedded_script(verbose: bool) -> str:
+        js_name = "lets-plot.min.js"
+        path = os.path.join("package_data", js_name)
+        js_code = pkgutil.get_data("lets_plot", path).decode("utf-8")
+        success_message = '<div style="color:darkblue;">Lets-Plot JS is embedded.</div>' if verbose else ""
+
+        return """
+            <script type="text/javascript" {data_attr}="{script_kind}">
+                window.letsPlotCall = function(f) {{f();}};
+                console.log('Embedding: {js_name}');
+                {js_code}
+            </script>
+            {success_message}
+            """.format(
+            data_attr=_ATT_SCRIPT_KIND,
+            script_kind=_SCRIPT_KIND_LIB_LOADING,
+            js_code=js_code,
+            js_name=js_name,
+            success_message=success_message)
+
+    @staticmethod
+    def _rand_string(size=6) -> str:
+        alphabet = string.ascii_letters + string.digits
+        # noinspection PyShadowingBuiltins
+        return ''.join([random.choice(alphabet) for _ in range(size)])

lets_plot/frontend_context/_mime_types.py

@@ -0,0 +1,7 @@
+#  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.
+
+# Supported MIME types
+TEXT_HTML = "text/html"
+LETS_PLOT_JSON = "application/vnd.lets-plot.v1+json"
+