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

lets_plot/_kbridge.py

@@ -0,0 +1,197 @@
+#  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)
+    # Old implementation (deprecated):
+    # return lets_plot_kotlin_bridge.generate_html(plot_spec)
+
+    # New implementation using get_display_html_for_raw_spec with default parameters
+    return lets_plot_kotlin_bridge.get_display_html_for_raw_spec(
+        plot_spec,
+        {},  # empty sizing_options -> defaults to notebookCell sizing (MIN width, SCALED height)
+        True,  # dynamic_script_loading
+        False,  # force_immediate_render
+        False  # responsive
+    )
+
+
+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_mvg(bytestring: Dict, output_width: float, output_height: float, unit: str, dpi: int, scale: float) -> str:
+    """
+    Export a plot to MVG format. For internal use.
+    """
+    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_mvg(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 _generate_static_html_page_for_raw_spec(
+        plot_spec: Dict,
+        sizing_options: Dict,
+        dynamic_script_loading: bool = False,
+        force_immediate_render: bool = False,
+        responsive: bool = False,
+        height100pct: bool = False
+) -> str:
+    plot_spec = _standardize_plot_spec(plot_spec)
+    sizing_options = standardize_dict(sizing_options)
+    scriptUrl = get_js_cdn_url()
+    return lets_plot_kotlin_bridge.get_static_html_page_for_raw_spec(
+        plot_spec,
+        scriptUrl,
+        sizing_options,
+        dynamic_script_loading,
+        force_immediate_render,
+        responsive,
+        height100pct
+    )
+
+
+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,
+        height100pct: 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 loads dynamically (asynchronously).
+        If False, assumes the library loads synchronously via a <script> tag in the page header.
+    force_immediate_render : bool, default=False
+        Controls the timing of plot rendering.
+        If True, renders the plot immediately.
+        If False, waits for the ResizeObserver event to ensure proper DOM layout.
+    responsive : bool, default=False
+        If True, makes the plot responsive to container size changes.
+    height100pct : bool, default=False
+        If True, sets the plot container div height to 100%.
+
+    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 are 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 a figure within container while preserving the 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,
+        height100pct
+    )

lets_plot/_type_utils.py

@@ -0,0 +1,133 @@
+#
+# 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 json
+import math
+from datetime import datetime, date, time, timezone
+
+from typing import Dict
+
+try:
+    import numpy
+except ImportError:
+    numpy = None
+
+try:
+    import pandas
+except ImportError:
+    pandas = None
+
+try:
+    import polars
+except ImportError:
+    polars = None
+
+try:
+    import shapely
+    import shapely.geometry
+except ImportError:
+    shapely = None
+
+try:
+    import jax.numpy as jnp
+except ImportError:
+    jnp = None
+
+
+# Parameter 'value' can also be pandas.DataFrame
+def standardize_dict(value: Dict) -> Dict:
+    result = {}
+    for k, v in value.items():
+        result[_standardize_value(k)] = _standardize_value(v)
+
+    return result
+
+
+def is_pandas_data_frame(v) -> bool:
+    return pandas and isinstance(v, pandas.DataFrame)
+
+
+def is_polars_dataframe(v):
+    return polars and isinstance(v, polars.DataFrame)
+
+
+def is_dict_or_dataframe(v):
+    return isinstance(v, dict) or (pandas and isinstance(v, pandas.DataFrame))
+
+
+def is_int(v):
+    return isinstance(v, int) or (numpy and isinstance(v, numpy.integer)) or (jnp and isinstance(v, jnp.integer))
+
+
+def is_float(v):
+    return isinstance(v, float) or (numpy and isinstance(v, numpy.floating)) or (jnp and isinstance(v, jnp.floating))
+
+
+def is_ndarray(data) -> bool:
+    return (numpy and isinstance(data, numpy.ndarray)) or (jnp and isinstance(data, jnp.ndarray))
+
+
+def is_number(v):
+    return is_int(v) or is_float(v)
+
+
+def _standardize_value(v):
+    if v is None:
+        return v
+    if isinstance(v, bool):
+        return bool(v)
+    if isinstance(v, str):
+        return str(v)
+    if is_float(v):
+        if math.isfinite(v):
+            return float(v)
+        # None for special values like 'nan' etc. because
+        # some JSON parsers (like com.google.gson.Gson) do not handle them well.
+        return None
+    if is_int(v):
+        return float(v)
+    if is_dict_or_dataframe(v):
+        return standardize_dict(v)
+    if is_polars_dataframe(v):
+        return standardize_dict(v.to_dict(as_series=False))
+    if isinstance(v, list):
+        return [_standardize_value(elem) for elem in v]
+    if isinstance(v, tuple):
+        return tuple(_standardize_value(elem) for elem in v)
+
+    if (numpy and isinstance(v, numpy.ndarray)):
+        # Process each array element individually.
+        # Don't use '.tolist()' because this will implicitly
+        # convert 'datetime64' values to unpredictable 'datetime' objects.
+        return [_standardize_value(x) for x in v]
+
+    if (pandas and isinstance(v, pandas.Series)) or (jnp and isinstance(v, jnp.ndarray)):
+        return _standardize_value(v.tolist())
+
+    # Universal NaT/NaN check
+    if pandas and pandas.isna(v):
+        return None
+
+    if isinstance(v, datetime):
+        # Datetime: to milliseconds since epoch (time zone aware)
+        return v.timestamp() * 1000
+    if isinstance(v, date):
+        # Local date: to milliseconds since epoch (midnight UTC)
+        return datetime.combine(v, time.min, tzinfo=timezone.utc).timestamp() * 1000
+    if isinstance(v, time):
+        # Local time: to milliseconds since midnight
+        return float(v.hour * 3600_000 + v.minute * 60_000 + v.second * 1000 + v.microsecond // 1000)
+    if numpy and isinstance(v, numpy.datetime64):
+        try:
+            # numpy.datetime64: to milliseconds since epoch (Unix time)
+            return float(v.astype('datetime64[ms]').astype(numpy.int64))
+        except:
+            return None
+
+    if shapely and isinstance(v, shapely.geometry.base.BaseGeometry):
+        return json.dumps(shapely.geometry.mapping(v))
+    try:
+        return repr(v)
+    except Exception:
+        raise Exception('Unsupported type: {0}({1})'.format(v, type(v)))

lets_plot/_version.py

@@ -0,0 +1,6 @@
+#
+# 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.
+#
+# see: https://www.python.org/dev/peps/pep-0440/#developmental-releases
+__version__ = '4.8.1rc1'

lets_plot/bistro/__init__.py

@@ -0,0 +1,16 @@
+#  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.
+
+from .corr import *
+from .im import *
+from .qq import *
+from .residual import *
+from .joint import *
+from .waterfall import *
+
+__all__ = (im.__all__ +
+           corr.__all__ +
+           qq.__all__ +
+           residual.__all__ +
+           joint.__all__ +
+           waterfall.__all__)

lets_plot/bistro/_plot2d_common.py

@@ -0,0 +1,106 @@
+#
+#  Copyright (c) 2023. JetBrains s.r.o.
+#  Use of this source code is governed by the MIT license that can be found in the LICENSE file.
+#
+from ..plot.core import DummySpec, aes
+from ..plot.geom import *
+from ..plot.marginal_layer import ggmarginal
+
+_BINS_DEF = 30
+_COLOR_DEF = "pen"
+
+_MARGINAL_ALPHA = .1
+
+
+def _get_bin_params_2d(xs, ys, binwidth, bins):
+    if isinstance(bins, int):
+        bins = [bins, bins]
+    if isinstance(binwidth, int) or isinstance(binwidth, float):
+        binwidth = [binwidth, binwidth]
+    if binwidth is not None or bins is not None or len(xs) == 0:
+        return binwidth, bins
+    binwidth_x = (max(xs) - min(xs)) / _BINS_DEF
+    binwidth_y = (max(ys) - min(ys)) / _BINS_DEF
+    binwidth_max = max(binwidth_x, binwidth_y)
+
+    return [binwidth_max, binwidth_max], bins
+
+
+def _get_geom2d_layer(geom_kind, binwidth2d, bins2d, color, color_by, size, alpha, show_legend):
+    if geom_kind == 'point':
+        return geom_point(color=color, size=size, alpha=alpha, show_legend=show_legend)
+    if geom_kind == 'tile':
+        return geom_bin2d(
+            aes(fill=('..count..' if color_by is None else color_by)),
+            bins=bins2d, binwidth=binwidth2d,
+            color=color, size=size, alpha=alpha,
+            show_legend=show_legend
+        )
+    if geom_kind == 'hex':
+        return geom_hex(
+            aes(fill=('..count..' if color_by is None else color_by)),
+            bins=bins2d, binwidth=binwidth2d,
+            color=color, size=size, alpha=alpha,
+            show_legend=show_legend
+        )
+    if geom_kind == 'density2d':
+        return geom_density2d(
+            aes(color=('..group..' if color_by is None else color_by)),
+            color=color, size=size, alpha=alpha,
+            show_legend=show_legend
+        )
+    if geom_kind == 'density2df':
+        return geom_density2df(
+            aes(fill=('..group..' if color_by is None else color_by)),
+            color=color, size=size, alpha=alpha,
+            show_legend=show_legend
+        )
+    if geom_kind == 'pointdensity':
+        return geom_pointdensity(
+            aes(color=('..density..' if color_by is None else color_by)),
+            color=color, size=size, alpha=alpha,
+            show_legend=show_legend
+        )
+    if geom_kind == 'none':
+        return None
+    raise Exception("Unknown geom '{0}'".format(geom_kind))
+
+
+def _get_marginal_layers(marginal, binwidth2d, bins2d, color, color_by, show_legend):
+    marginal_color = None if color_by is not None else (color or _COLOR_DEF)
+
+    def bin_param_to_1d(param2d, side):
+        if param2d is None:
+            return None
+        else:
+            if side in ['t', 'b']:
+                return param2d[0]
+            else:
+                return param2d[1]
+
+    def _get_marginal_layer(geom_kind, side, size):
+        if geom_kind in ['dens', 'density']:
+            layer = geom_area(stat='density', position='identity', color=marginal_color, fill=marginal_color,
+                              alpha=_MARGINAL_ALPHA, show_legend=show_legend)
+        elif geom_kind in ['hist', 'histogram']:
+            binwidth = bin_param_to_1d(binwidth2d, side)
+            bins = bin_param_to_1d(bins2d, side)
+            layer = geom_histogram(bins=bins, binwidth=binwidth,
+                                   color=marginal_color, fill=marginal_color, alpha=_MARGINAL_ALPHA,
+                                   show_legend=show_legend)
+        elif geom_kind in ['box', 'boxplot']:
+            layer = geom_boxplot(color=marginal_color, fill=marginal_color, alpha=_MARGINAL_ALPHA, show_legend=show_legend)
+        else:
+            raise Exception("Unknown geom '{0}'".format(geom_kind))
+
+        return ggmarginal(side, size=size, layer=layer)
+
+    result = DummySpec()
+    for layer_description in filter(bool, marginal.split(",")):
+        params = layer_description.strip().split(":")
+        geom_kind, sides = params[0].strip(), params[1].strip()
+        size = float(params[2].strip()) if len(params) > 2 else None
+        for side in sides:
+            result += _get_marginal_layer(geom_kind, side, size)
+
+    return result