lets-plot 4.8.0rc1__cp313-cp313-macosx_12_0_arm64.whl

lets_plot/__init__.py

@@ -0,0 +1,283 @@
+#
+# 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 pkgutil import extend_path
+from typing import Dict, Union
+
+# To handle the situation when the 'lets_plot' package is shared by modules in different locations.
+__path__ = extend_path(__path__, __name__)
+
+from ._version import __version__
+from ._global_settings import _settings, is_production, get_global_bool
+from ._global_settings import NO_JS, OFFLINE
+
+from .plot import *
+from .export import *
+from .frontend_context import *
+from .mapping import *
+from .settings_utils import *
+from .plot._global_theme import _set_global_theme
+
+__all__ = (plot.__all__ +
+           frontend_context.__all__ +
+           mapping.__all__ +
+           settings_utils.__all__ +
+           export.__all__ +
+           ['LetsPlot'])
+
+from .frontend_context import _configuration as cfg
+
+
+class LetsPlot:
+    """
+    Initialize the library and its options.
+    """
+
+    @classmethod
+    def setup_html(cls, *,
+                   isolated_frame: bool = None,
+                   offline: bool = None,
+                   no_js: bool = None,
+                   show_status: bool = False) -> None:
+        """
+        Configure Lets-Plot HTML output.
+        Depending on the usage, LetsPlot generates different HTML to show plots.
+        In most cases LetsPlot will detect type of the environment automatically.
+        Auto-detection can be overwritten using this method parameters.
+
+        Parameters
+        ----------
+        isolated_frame : bool
+            True - generate HTML 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.
+            Default (None): 'connected' mode in production environment
+            and 'offline' mode in dev environment.
+        no_js : bool, default=False
+            True - do not generate HTML+JS as an output - just static SVG image.
+            Note that without JS interactive maps and tooltips doesn't work!
+        show_status : bool, default=False
+            Whether to show status of loading of the Lets-Plot JS library.
+            Only applicable when the Lets-Plot JS library is preloaded.
+
+        Examples
+        --------
+        .. jupyter-execute::
+            :linenos:
+            :emphasize-lines: 2
+
+            from lets_plot import *
+            LetsPlot.setup_html()
+            ggplot({'x': [0], 'y': [0]}, aes('x', 'y')) + geom_point()
+
+        |
+
+        .. jupyter-execute::
+            :linenos:
+            :emphasize-lines: 2-3
+
+            from lets_plot import *
+            LetsPlot.setup_html(isolated_frame=False, offline=True, \\
+                                no_js=True, show_status=True)
+            ggplot({'x': [0], 'y': [0]}, aes('x', 'y')) + geom_point()
+
+        """
+        if not (isinstance(isolated_frame, bool) or isolated_frame is None):
+            raise ValueError("'isolated' argument is not boolean: {}".format(type(isolated_frame)))
+        if not (isinstance(offline, bool) or offline is None):
+            raise ValueError("'offline' argument is not boolean: {}".format(type(offline)))
+        if not (isinstance(no_js, bool) or no_js is None):
+            raise ValueError("'no_js' argument is not boolean: {}".format(type(no_js)))
+        if not isinstance(show_status, bool):
+            raise ValueError("'show_status' argument is not boolean: {}".format(type(show_status)))
+
+        offline = offline if offline is not None else get_global_bool(OFFLINE)
+        no_js = no_js if no_js is not None else get_global_bool(NO_JS)
+
+        cfg._setup_html_context(isolated_frame=isolated_frame,
+                                offline=offline,
+                                no_js=no_js,
+                                show_status=show_status)
+
+    @classmethod
+    def set(cls, settings: Dict):
+        """
+        Set up library options.
+        For more info see `Configuring Globally <https://lets-plot.org/python/pages/basemap_tiles.html#configuring-globally>`__.
+
+        Parameters
+        ----------
+        settings : dict
+            Dictionary of settings.
+
+        Notes
+        -----
+        List of possible settings:
+
+        - html_isolated_frame : preload Lets-Plot JS library or not (bool). Do not use this parameter explicitly. Instead you should call `LetsPlot.setup_html() <https://lets-plot.org/python/pages/api/lets_plot.LetsPlot.html#lets_plot.LetsPlot.setup_html>`__.
+        - offline : to work with notebook without the Internet connection (bool). Do not use this parameter explicitly. Instead you should call `LetsPlot.setup_html() <https://lets-plot.org/python/pages/api/lets_plot.LetsPlot.html#lets_plot.LetsPlot.setup_html>`__.
+        - no_js : do not generate HTML+JS as an output (bool). Do not use this parameter explicitly. Instead you should call `LetsPlot.setup_html() <https://lets-plot.org/python/pages/api/lets_plot.LetsPlot.html#lets_plot.LetsPlot.setup_html>`__. Also note that without JS interactive maps and tooltips doesn't work!
+
+        Interactive map settings could also be specified:
+
+        - maptiles_kind : kind of the tiles, could be 'raster_zxy' or 'vector_lets_plot'. Do not use this parameter explicitly. Instead you should construct it with functions `maptiles_zxy() <https://lets-plot.org/python/pages/api/lets_plot.maptiles_zxy.html>`__ and `maptiles_lets_plot() <https://lets-plot.org/python/pages/api/lets_plot.maptiles_lets_plot.html>`__.
+        - maptiles_url : address of the tile server (str). Do not use this parameter explicitly. Instead you should construct it with functions `maptiles_zxy() <https://lets-plot.org/python/pages/api/lets_plot.maptiles_zxy.html>`__ and `maptiles_lets_plot() <https://lets-plot.org/python/pages/api/lets_plot.maptiles_lets_plot.html>`__.
+        - maptiles_theme : tiles theme, could be 'color', 'light' or 'dark'. Do not use this parameter explicitly. Instead you should construct it with function `maptiles_lets_plot() <https://lets-plot.org/python/pages/api/lets_plot.maptiles_lets_plot.html>`__.
+        - maptiles_attribution : an attribution or a copyright notice to display on the map as required by the tile license (str, supports HTML links). Do not use this parameter explicitly. Instead you should construct it with function `maptiles_zxy() <https://lets-plot.org/python/pages/api/lets_plot.maptiles_zxy.html>`__.
+        - maptiles_min_zoom : minimal zoom limit (int). Do not use this parameter explicitly. Instead you should construct it with function `maptiles_zxy() <https://lets-plot.org/python/pages/api/lets_plot.maptiles_zxy.html>`__.
+        - maptiles_max_zoom : maximal zoom limit (int). Do not use this parameter explicitly. Instead you should construct it with function `maptiles_zxy() <https://lets-plot.org/python/pages/api/lets_plot.maptiles_zxy.html>`__.
+
+        Examples
+        --------
+        .. jupyter-execute::
+            :linenos:
+            :emphasize-lines: 4
+
+            from lets_plot import *
+            from lets_plot import tilesets
+            LetsPlot.setup_html()
+            LetsPlot.set(tilesets.LETS_PLOT_LIGHT)
+            ggplot() + geom_livemap()
+
+        |
+
+        .. jupyter-execute::
+            :linenos:
+            :emphasize-lines: 4
+
+            from lets_plot import *
+            from lets_plot import tilesets
+            LetsPlot.setup_html()
+            LetsPlot.set(tilesets.LETS_PLOT_BW)
+            ggplot() + geom_livemap()
+
+        """
+        if is_production():
+            _settings.update(settings)
+        else:
+            _settings.update({'dev_' + key: value for key, value in settings.items()})
+
+    @classmethod
+    def set_theme(cls, theme: Union['core.FeatureSpec', 'core.FeatureSpecArray']):
+        """
+        Set up global theme.
+
+        Parameters
+        ----------
+        theme : spec
+            Theme spec provided by `theme(...) <https://lets-plot.org/python/pages/api/lets_plot.theme.html>`__, ``theme_xxx()``, ``flavor_xxx()`` functions, or their sum.
+
+        """
+        if theme is None:
+            _set_global_theme(None)
+            return
+
+        if theme.kind != 'theme' and not (theme.kind == 'feature-list' and all(f.kind == 'theme' for f in theme)):
+            raise ValueError("Only `theme(...)`, `theme_xxx()`, `flavor_xxx()`, or a sum of them are supported")
+
+        _set_global_theme(theme)
+
+    @classmethod
+    def setup_show_ext(cls, *,
+                       exec: str = None,
+                       new: bool = False) -> None:
+        """
+        Configure Lets-Plot to show its HTML output in an external browser.
+
+        When the "show externally" is set up, an invocation of ``figire.show()`` will
+        - generate HTML output
+        - save it to a temporary file
+        - open the file in the default web browser or in a web browser specified by the ``exec`` parameter.
+
+        Parameters
+        ----------
+        exec : str, optional
+            Specify an app to open the generated temporary HTML file.
+            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.
+            The ``new`` parameter is only applicable when the ``exec`` parameter is not specified.
+            Please note that the ``new`` parameter is not supported by all web browsers and all OS-s.
+
+        Examples
+        --------
+        .. code-block::
+            :linenos:
+            :emphasize-lines: 3
+
+            # Show the plot in the default web browser.
+            from lets_plot import *
+            LetsPlot.setup_show_ext()
+            p = ggplot() + geom_point(x=0, y=0)
+            p.show()
+
+        |
+
+        .. code-block::
+            :linenos:
+            :emphasize-lines: 3
+
+            # Show the plot in the new window of the default web browser if possible.
+            from lets_plot import *
+            LetsPlot.setup_show_ext(new=True)
+            p = ggplot() + geom_point(x=0, y=0)
+            p.show()
+
+        |
+
+        .. code-block::
+            :linenos:
+            :emphasize-lines: 4
+
+            # Show the plot in the Chrome web browser for Windows.
+            # This is the default setup path. Replace the file path with your own if it differs.
+            from lets_plot import *
+            LetsPlot.setup_show_ext(exec='C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe --app=%s')
+            p = ggplot() + geom_point(x=0, y=0)
+            p.show()
+
+        |
+
+        .. code-block::
+            :linenos:
+            :emphasize-lines: 3
+
+            # Show the plot in the Safari web browser for macOS.
+            from lets_plot import *
+            LetsPlot.setup_show_ext(exec='open -a safari %s')
+            p = ggplot() + geom_point(x=0, y=0)
+            p.show()
+
+        |
+
+        .. code-block::
+            :linenos:
+            :emphasize-lines: 4
+
+            # Show the plot in the Chrome web browser for macOS in the application mode.
+            # This is the default setup path. Replace the path with your own if it differs.
+            from lets_plot import *
+            LetsPlot.setup_show_ext(exec='/Applications/Google\\ Chrome.app/Contents/MacOS/Google\\ Chrome --app=%s')
+            p = ggplot() + geom_point(x=0, y=0)
+            p.show()
+
+        |
+
+        .. code-block::
+            :linenos:
+            :emphasize-lines: 3
+
+            # Show the plot in the Chrome web browser for Linux.
+            from lets_plot import *
+            LetsPlot.setup_show_ext(exec='google-chrome --app=%s')
+            p = ggplot() + geom_point(x=0, y=0)
+            p.show()
+
+        """
+        cfg._setup_wb_html_context(exec=exec, new=new)

lets_plot/_global_settings.py

@@ -0,0 +1,192 @@
+#
+# 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
+from typing import Any
+
+from ._version import __version__
+
+# Supported environment variables.
+# 'bool' variables accept values:
+#       True: 'true', '1', 't', 'y', 'yes'
+#       False: 'false', '0', 'f', 'n', 'no'
+#
+# Production mode env variables:
+ENV_HTML_ISOLATED_FRAME = 'LETS_PLOT_HTML_ISOLATED_FRAME'  # bool
+ENV_OFFLINE = 'LETS_PLOT_OFFLINE'  # bool
+ENV_NO_JS = 'LETS_PLOT_NO_JS'  # bool
+ENV_MAX_WIDTH = 'LETS_PLOT_MAX_WIDTH'
+ENV_MAX_HEIGHT = 'LETS_PLOT_MAX_HEIGHT'
+ENV_MAPTILES_KIND = 'LETS_PLOT_MAPTILES_KIND'
+ENV_MAPTILES_URL = 'LETS_PLOT_MAPTILES_URL'
+ENV_MAPTILES_THEME = 'LETS_PLOT_MAPTILES_THEME'
+ENV_GEOCODING_URL = 'LETS_PLOT_GEOCODING_URL'
+
+# Dev mode env variables have 'LETS_PLOT_DEV_' prefix instead of 'LETS_PLOT_'.
+ENV_DEV_HTML_ISOLATED_FRAME = 'LETS_PLOT_DEV_HTML_ISOLATED_FRAME'  # bool
+ENV_DEV_OFFLINE = 'LETS_PLOT_DEV_OFFLINE'  # bool
+ENV_DEV_NO_JS = 'LETS_PLOT_DEV_NO_JS'  # bool
+ENV_DEV_MAX_WIDTH = 'LETS_PLOT_DEV_MAX_WIDTH'
+ENV_DEV_MAX_HEIGHT = 'LETS_PLOT_DEV_MAX_HEIGHT'
+ENV_DEV_MAGICK_EXPORT = 'LETS_PLOT_DEV_MAGICK_EXPORT'  # bool
+ENV_DEV_MAPTILES_KIND = 'LETS_PLOT_DEV_MAPTILES_KIND'
+ENV_DEV_MAPTILES_URL = 'LETS_PLOT_DEV_MAPTILES_URL'
+ENV_DEV_MAPTILES_THEME = 'LETS_PLOT_DEV_MAPTILES_THEME'
+ENV_DEV_GEOCODING_URL = 'LETS_PLOT_DEV_GEOCODING_URL'
+
+# Options
+
+HTML_ISOLATED_FRAME = 'html_isolated_frame'
+OFFLINE = 'offline'
+NO_JS = 'no_js'
+JS_BASE_URL = 'js_base_url'
+JS_PATH_TO_FILE = 'js_path_to_file'
+JS_NAME = 'js_name'
+JS_URL_MANUAL = 'js_url_manual'
+MAX_WIDTH = 'max_width'
+MAX_HEIGHT = 'max_height'
+
+MAPTILES_KIND = 'maptiles_kind'
+MAPTILES_URL = 'maptiles_url'
+MAPTILES_THEME = 'maptiles_theme'
+MAPTILES_ATTRIBUTION = 'maptiles_attribution'
+MAPTILES_MIN_ZOOM = 'maptiles_min_zoom'
+MAPTILES_MAX_ZOOM = 'maptiles_max_zoom'
+MAPTILES_SOLID_FILL_COLOR = 'maptiles_fill_color'
+TILES_VECTOR_LETS_PLOT = 'vector_lets_plot'
+TILES_RASTER_ZXY = 'raster_zxy'
+TILES_SOLID = 'solid'
+TILES_CHESSBOARD = 'chessboard'
+GEOCODING_PROVIDER_URL = 'geocoding_url'
+GEOCODING_ROUTE = '/map_data/geocoding'
+FRAGMENTS_ENABLED = 'fragments_enabled'
+
+_DATALORE_TILES_SERVICE = 'wss://tiles.datalore.jetbrains.com'
+_DATALORE_TILES_ATTRIBUTION = '<a href="https://lets-plot.org">\u00a9 Lets-Plot</a>, map data: <a href="https://www.openstreetmap.org/copyright">\u00a9 OpenStreetMap contributors</a>.'
+_DATALORE_TILES_THEME = 'color'
+_DATALORE_TILES_MIN_ZOOM = 1
+_DATALORE_TILES_MAX_ZOOM = 15
+_DATALORE_GEOCODING_SERVICE = 'https://geo2.datalore.jetbrains.com'
+
+
+def _init_value(actual_name: str, def_val: Any) -> Any:
+    env_val = _get_env_val(actual_name)
+    return env_val if env_val else def_val
+
+
+def _get_env_val(actual_name: str) -> Any:
+    env_name = "LETS_PLOT_{}".format(actual_name.upper())
+    return os.environ.get(env_name)
+
+
+_settings = {
+    OFFLINE: _init_value(OFFLINE, False),  # default: download from CDN
+    NO_JS: _init_value(NO_JS, False),
+    # JS_BASE_URL: 'https://dl.bintray.com/jetbrains/lets-plot',
+    # JS_BASE_URL: "https://cdnjs.cloudflare.com/ajax/libs/lets-plot",
+    JS_BASE_URL: "https://cdn.jsdelivr.net/gh/JetBrains/lets-plot@v{version}".format(version=__version__),
+    JS_PATH_TO_FILE: "js-package/distr",
+    JS_NAME: '',  # default: lets-plot.min.js
+    GEOCODING_PROVIDER_URL: _init_value(GEOCODING_PROVIDER_URL, _DATALORE_GEOCODING_SERVICE),
+    MAPTILES_KIND: _init_value(MAPTILES_KIND, TILES_VECTOR_LETS_PLOT),
+    MAPTILES_URL: _init_value(MAPTILES_URL, _DATALORE_TILES_SERVICE),
+    MAPTILES_ATTRIBUTION: _init_value(MAPTILES_ATTRIBUTION, _DATALORE_TILES_ATTRIBUTION),
+    MAPTILES_THEME: _init_value(MAPTILES_THEME, _DATALORE_TILES_THEME),
+    MAPTILES_MIN_ZOOM: _init_value(MAPTILES_MIN_ZOOM, _DATALORE_TILES_MIN_ZOOM),
+    MAPTILES_MAX_ZOOM: _init_value(MAPTILES_MAX_ZOOM, _DATALORE_TILES_MAX_ZOOM),
+
+    'dev_' + OFFLINE: _init_value('dev_' + OFFLINE, True),  # default: embed js into the notebook
+    'dev_' + NO_JS: _init_value('dev_' + NO_JS, False),
+    # We don't publish "dev" version, it must be served on localhost:
+    # $ cd lets-plot
+    # ./gradlew js-package:jsBrowserDevelopmentWebpack
+    # $ python -m http.server 8080
+    'dev_' + JS_BASE_URL: "http://127.0.0.1:8080",
+    'dev_' + JS_PATH_TO_FILE: "js-package/build/dist/js/developmentExecutable",
+    'dev_' + JS_NAME: '',  # default: lets-plot.js
+    'dev_' + GEOCODING_PROVIDER_URL: _init_value('dev_' + GEOCODING_PROVIDER_URL, _DATALORE_GEOCODING_SERVICE),
+    'dev_' + MAPTILES_KIND: _init_value('dev_' + MAPTILES_KIND, TILES_VECTOR_LETS_PLOT),
+    'dev_' + MAPTILES_URL: _init_value('dev_' + MAPTILES_URL, _DATALORE_TILES_SERVICE),
+    'dev_' + MAPTILES_ATTRIBUTION: _init_value('dev_' + MAPTILES_ATTRIBUTION, _DATALORE_TILES_ATTRIBUTION),
+    'dev_' + MAPTILES_THEME: _init_value('dev_' + MAPTILES_THEME, _DATALORE_TILES_THEME),
+    'dev_' + MAPTILES_MIN_ZOOM: _init_value('dev_' + MAPTILES_MIN_ZOOM, _DATALORE_TILES_MIN_ZOOM),
+    'dev_' + MAPTILES_MAX_ZOOM: _init_value('dev_' + MAPTILES_MAX_ZOOM, _DATALORE_TILES_MAX_ZOOM),
+}
+
+
+def _to_actual_name(name: str) -> str:
+    if name.startswith("dev_"):
+        return name
+
+    return name if is_production() else 'dev_' + name
+
+
+def _get_global_val_intern(actual_name: str) -> Any:
+    # `settings` dict has precedence over environment variables.
+    env_val = _get_env_val(actual_name)
+    return _settings.get(actual_name, env_val)
+
+
+def is_production() -> bool:
+    return 'dev' not in __version__
+
+
+def get_js_cdn_url() -> str:
+    if has_global_value(JS_URL_MANUAL):
+        return get_global_str(JS_URL_MANUAL)
+
+    base_url = get_global_str(JS_BASE_URL)
+
+    js_path_to_file = get_global_str(JS_PATH_TO_FILE)
+
+    if has_global_value(JS_NAME):
+        name = get_global_str(JS_NAME)
+    else:
+        name = "lets-plot.min.js" if is_production() else "lets-plot.js".format(version=__version__)
+        # name = "lets-plot-{version}.{suffix}".format(version=__version__, suffix=suffix)
+        # name = "lets-plot.{suffix}".format(suffix=suffix)
+
+    # url = "{base_url}/{name}".format(base_url=base_url, name=name)
+    url = "{base_url}/{js_path_to_file}/{name}".format(base_url=base_url, js_path_to_file=js_path_to_file, name=name)
+    return url
+
+
+def has_global_value(name: str) -> bool:
+    val = _get_global_val_intern(_to_actual_name(name))
+
+    if isinstance(val, bool):
+        return True
+    if isinstance(val, str) and not val.strip():
+        return False
+    return bool(val)
+
+
+def get_global_val(name: str) -> Any:
+    if not has_global_value(name):
+        raise ValueError("Not defined '{}'".format(_to_actual_name(name)))
+
+    return _get_global_val_intern(_to_actual_name(name))
+
+
+def get_global_str(name: str) -> str:
+    val = get_global_val(name)
+    if not isinstance(val, str):
+        raise ValueError("Not string value: ['{}'] : {}".format(_to_actual_name(name), type(val)))
+    return val
+
+
+def get_global_bool(name: str) -> bool:
+    val = get_global_val(name)
+    if isinstance(val, bool):
+        return val
+
+    if isinstance(val, str):
+        if val.lower() in ['true', '1', 't', 'y', 'yes']:
+            return True
+        elif val.lower() in ['false', '0', 'f', 'n', 'no']:
+            return False
+        else:
+            raise ValueError("Can't convert str to boolean : ['{}'] : {}".format(_to_actual_name(name), val))
+
+    raise ValueError("Not boolean value: ['{}'] : {}".format(_to_actual_name(name), type(val)))

lets_plot/_kbridge.py

@@ -0,0 +1,149 @@
+#  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.
+
+# noinspection PyUnresolvedReferences
+from typing import Dict
+
+import lets_plot_kotlin_bridge
+
+from ._global_settings import get_js_cdn_url
+from ._type_utils import standardize_dict
+
+
+def _generate_dynamic_display_html(plot_spec: Dict) -> str:
+    plot_spec = _standardize_plot_spec(plot_spec)
+    return lets_plot_kotlin_bridge.generate_html(plot_spec)
+
+
+def _generate_svg(plot_spec: Dict, w: float = None, h: float = None, unit: str = None, use_css_pixelated_image_rendering: bool=True) -> str:
+    plot_spec = _standardize_plot_spec(plot_spec)
+    w = -1.0 if w is None else float(w)
+    h = -1.0 if h is None else float(h)
+    unit = '' if unit is None else str(unit)  # None is not a valid value for str type - PyArg_ParseTuple will fail
+    return lets_plot_kotlin_bridge.export_svg(plot_spec, w, h, unit, use_css_pixelated_image_rendering)
+
+def _generate_png(bytestring: Dict, output_width: float, output_height: float, unit: str, dpi: int, scale: float) -> str:
+    """
+    Export a plot to PNG format. Returns base64 encoded string of the PNG image.
+    """
+    plot_spec = _standardize_plot_spec(bytestring)
+    output_width = -1.0 if output_width is None else float(output_width)
+    output_height = -1.0 if output_height is None else float(output_height)
+    unit = '' if unit is None else str(unit)  # None is not a valid value for str type - PyArg_ParseTuple will fail
+    dpi = -1 if dpi is None else int(dpi)
+    scale = -1.0 if scale is None else float(scale)
+    return lets_plot_kotlin_bridge.export_png(plot_spec, output_width, output_height, unit, dpi, scale)
+
+
+def _generate_static_html_page(plot_spec: Dict, iframe: bool) -> str:
+    plot_spec = _standardize_plot_spec(plot_spec)
+    scriptUrl = get_js_cdn_url()
+    return lets_plot_kotlin_bridge.export_html(plot_spec, scriptUrl, iframe)
+
+
+def _standardize_plot_spec(plot_spec: Dict) -> Dict:
+    """
+    :param plot_spec: dict
+    """
+    if not isinstance(plot_spec, dict):
+        raise ValueError("dict expected but was {}".format(type(plot_spec)))
+
+    return standardize_dict(plot_spec)
+
+
+def _generate_static_configure_html() -> str:
+    """
+    Generate static HTML configuration.
+
+    Returns
+    -------
+    str
+        HTML string containing the static configuration with the script URL from global settings.
+    """
+    scriptUrl = get_js_cdn_url()
+    return lets_plot_kotlin_bridge.get_static_configure_html(scriptUrl)
+
+
+def _generate_display_html_for_raw_spec(
+        plot_spec: Dict,
+        sizing_options: Dict,
+        *,
+        dynamic_script_loading: bool = False,
+        force_immediate_render: bool = False,
+        responsive: bool = False
+) -> str:
+    """
+    Generate HTML for displaying a plot from 'raw' specification (not processed by plot backend)
+    with customizable options.
+
+    Parameters
+    ----------
+    plot_spec : Dict
+        Dict containing the plot specification.
+    sizing_options : Dict
+        Dict containing sizing policy options (width_mode, height_mode, width, height).
+    dynamic_script_loading : bool, default=False
+        Controls how the generated JS code interacts with the lets-plot JS library.
+        If True, assumes the library will be loaded dynamically.
+        If False, assumes the library is already present in the page header (static loading).
+    force_immediate_render : bool, default=False
+        Controls the timing of plot rendering.
+        If True, forces immediate plot rendering.
+        If False, waits for ResizeObserver(JS) event and renders the plot after the plot
+        container is properly layouted in DOM.
+    responsive : bool, default=False
+        If True, makes the plot responsive to container size changes.
+
+    Returns
+    -------
+    str
+        HTML string containing the plot with specified options.
+
+    Notes
+    -----
+    The sizing_options dict supports the following structure:
+    {
+        'width_mode': str,     # 'fixed', 'min', 'fit', 'scaled' (case-insensitive)
+        'height_mode': str,    # 'fixed', 'min', 'fit', 'scaled' (case-insensitive)
+        'width': number,       # optional
+        'height': number       # optional
+    }
+
+    Sizing modes determine how the plot dimensions are calculated:
+
+    1. FIXED mode:
+       - Uses the explicitly provided width/height values
+       - Falls back to the default figure size if no values provided
+       - Not responsive to container size
+
+    2. MIN mode:
+       Applies the smallest dimension among:
+       - The default figure size
+       - The specified width/height (if provided)
+       - The container size (if available)
+
+    3. FIT mode:
+       Uses either:
+       - The specified width/height if provided
+       - Otherwise uses container size if available
+       - Falls back to default figure size if neither is available
+
+    4. SCALED mode:
+       - Always preserves the figure's aspect ratio
+       - Typical usage: one dimension (usually width) uses FIXED/MIN/FIT mode
+         and SCALED height adjusts to maintain aspect ratio
+       - Special case: when both width and height are SCALED:
+         * Requires container size to be available
+         * Fits figure within container while preserving aspect ratio
+         * Neither dimension is predetermined
+
+    """
+    plot_spec = _standardize_plot_spec(plot_spec)
+    sizing_options = standardize_dict(sizing_options)
+    return lets_plot_kotlin_bridge.get_display_html_for_raw_spec(
+        plot_spec,
+        sizing_options,
+        dynamic_script_loading,
+        force_immediate_render,
+        responsive
+    )