lets-plot 4.8.1rc1__cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

lets_plot/__init__.py

@@ -0,0 +1,382 @@
+#
+# 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,
+                   **kwargs) -> None:
+        """
+        Configure Lets-Plot HTML output.
+        This method should typically be called before rendering any plots.
+        Depending on the usage, Lets-Plot generates different HTML to show plots.
+        In most cases Lets-Plot will detect the type of the environment automatically.
+        Use this method to adjust or override the autoconfigured output mode.
+
+        Parameters
+        ----------
+        isolated_frame : bool
+            True - generate HTML which can be used in iframe or in a standalone HTML document.
+            False - preload Lets-Plot JS library. Notebook cell output will only consist
+            of HTML for the plot rendering. Default: 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 a notebook without the Internet connection.
+            False - load Lets-Plot JS library from CDN.
+            Default: 'connected' mode in the production environment, 'offline' mode in the 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 don't work!
+        show_status : bool, default=False
+            Whether to show the Lets-Plot JS library loading status.
+            Only applicable when the Lets-Plot JS library is preloaded.
+        **kwargs
+            Advanced display options for developers testing in new environments
+            or debugging rendering behavior. These options control the underlying
+            HTML rendering:
+
+            - isolated_webview_panel : bool
+                If True, generates HTML for an isolated webview panel with dynamic script loading.
+                When enabled, the 'isolated_frame' parameter is ignored.
+            - width_mode : str
+                Plot width sizing mode: 'fixed', 'min', 'fit', or 'scaled'.
+                Requires height_mode to also be specified.
+            - height_mode : str
+                Plot height sizing mode: 'fixed', 'min', 'fit', or 'scaled'.
+                Requires width_mode to also be specified.
+            - width : float
+                Explicit width value in px (used with certain sizing modes).
+            - height : float
+                Explicit height value in px (used with certain sizing modes).
+            - force_immediate_render : bool
+                Controls the timing of plot rendering.
+                If True, renders plot immediately.
+                If False, waits for the ResizeObserver event to ensure proper DOM layout.
+            - responsive : bool
+                If True, the plot automatically resizes when the container is resized.
+            - height100pct : bool
+                If True, sets the plot container div height to 100%.
+
+            Sizing modes:
+
+            - 'fixed': Uses specified width/height or default size (not responsive)
+            - 'min': Uses smallest of: default size, specified size, and container size
+            - 'fit': Uses container size or specified size if provided
+            - 'scaled': Adjusts to preserve the aspect ratio
+
+
+        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)))
+
+        # Validate dev options
+        if kwargs:
+            supported_keys = {'width_mode', 'height_mode', 'width', 'height',
+                             'responsive', 'force_immediate_render', 'height100pct', 'isolated_webview_panel'}
+            unsupported_keys = set(kwargs.keys()) - supported_keys
+            if unsupported_keys:
+                raise ValueError(
+                    "Unsupported parameter(s): {}".format(', '.join(sorted(unsupported_keys)))
+                )
+
+            has_width_mode = 'width_mode' in kwargs
+            has_height_mode = 'height_mode' in kwargs
+            if has_width_mode != has_height_mode:
+                raise ValueError(
+                    "Both 'width_mode' and 'height_mode' must be specified together. "
+                    "Got: width_mode={}, height_mode={}".format(
+                        kwargs.get('width_mode', 'not specified'),
+                        kwargs.get('height_mode', 'not specified')
+                    )
+                )
+
+            if has_width_mode:
+                valid_modes = ['fixed', 'min', 'fit', 'scaled']
+                width_mode = kwargs['width_mode']
+                if not isinstance(width_mode, str):
+                    raise ValueError("'width_mode' must be a string, got: {}".format(type(width_mode)))
+                if width_mode.lower() not in valid_modes:
+                    raise ValueError(
+                        "'width_mode' must be one of {}, got: '{}'".format(valid_modes, width_mode)
+                    )
+
+            if has_height_mode:
+                valid_modes = ['fixed', 'min', 'fit', 'scaled']
+                height_mode = kwargs['height_mode']
+                if not isinstance(height_mode, str):
+                    raise ValueError("'height_mode' must be a string, got: {}".format(type(height_mode)))
+                if height_mode.lower() not in valid_modes:
+                    raise ValueError(
+                        "'height_mode' must be one of {}, got: '{}'".format(valid_modes, height_mode)
+                    )
+
+            if 'width' in kwargs:
+                width = kwargs['width']
+                if not isinstance(width, (int, float)):
+                    raise ValueError("'width' must be a number, got: {}".format(type(width)))
+
+            if 'height' in kwargs:
+                height = kwargs['height']
+                if not isinstance(height, (int, float)):
+                    raise ValueError("'height' must be a number, got: {}".format(type(height)))
+
+            # Validate boolean options
+            for bool_option in ['responsive', 'force_immediate_render', 'height100pct', 'isolated_webview_panel']:
+                if bool_option in kwargs and not isinstance(kwargs[bool_option], bool):
+                    raise ValueError("'{}' must be a boolean, got: {}".format(
+                        bool_option, type(kwargs[bool_option])
+                    ))
+
+            # Warn if isolated_webview_panel is True
+            if kwargs.get('isolated_webview_panel'):
+                print("WARNING: 'isolated_webview_panel=True' - using isolated webview panel context. "
+                      "The 'isolated_frame' parameter will be ignored.")
+
+        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,
+                                dev_options=kwargs)
+
+    @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)))