lets-plot 4.7.0rc1__cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

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.7.0rc1'

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,100 @@
+#
+#  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 == '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

lets_plot/bistro/corr.py

@@ -0,0 +1,447 @@
+#  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.
+#
+
+"""Correlation matrix implementation module"""
+from typing import Any
+
+from lets_plot.plot.util import is_pandas_data_frame
+
+try:
+    import numpy
+except ImportError:
+    numpy = None
+
+try:
+    import pandas
+except ImportError:
+    pandas = None
+
+from lets_plot.plot.core import PlotSpec
+
+__all__ = ['corr_plot']
+
+
+def _is_corr_matrix(data: Any):
+    if is_pandas_data_frame(data):
+        if data.shape[0] != data.shape[1]:
+            return False
+
+        if not (all(col_type == 'float64' for col_type in data.dtypes)):
+            return False
+
+        for column in data:
+            import math
+            if not all(math.isnan(v) or (1.0 >= v >= -1.0) for v in data[column]):
+                return False
+
+        return True
+
+    elif isinstance(data, dict):
+        m = len(data.keys())
+        for column in data.values():
+            if not isinstance(column, (list, tuple)):
+                return False
+
+            if len(column) != m:
+                return False
+
+            import math
+            for v in column:
+                if not isinstance(v, float):
+                    return False
+
+                if math.isnan(v):
+                    return True
+
+                if 1.0 >= v >= -1.0:
+                    return True
+
+                return False
+
+            return True
+    else:
+        return False
+
+
+class corr_plot:
+    """
+    This class is intended to build correlation matrix plot.
+
+    Notes
+    -----
+    To hide axis tooltips, set 'blank' or the result of `element_blank()`
+    to the `axis_tooltip`, `axis_tooltip_x` or `axis_tooltip_y` parameter of the `theme()`.
+
+    Examples
+    --------
+    .. jupyter-execute::
+        :linenos:
+        :emphasize-lines: 7
+
+        import numpy as np
+        from lets_plot import *
+        from lets_plot.bistro.corr import *
+        LetsPlot.setup_html()
+        np.random.seed(42)
+        data = {var: np.random.poisson(size=10) for var in 'abcdef'}
+        corr_plot(data).tiles().build()
+
+    |
+
+    .. jupyter-execute::
+        :linenos:
+        :emphasize-lines: 7-9
+
+        import numpy as np
+        from lets_plot import *
+        from lets_plot.bistro.corr import *
+        LetsPlot.setup_html()
+        np.random.seed(42)
+        data = {var: np.random.uniform(size=10) for var in 'abcd'}
+        corr_plot(data).tiles(type='upper', diag=True)\\
+            .labels(type='upper', diag=True, map_size=True, color='black')\\
+            .palette_RdBu().build()
+
+    |
+
+    .. jupyter-execute::
+        :linenos:
+        :emphasize-lines: 7-9
+
+        import numpy as np
+        from lets_plot import *
+        from lets_plot.bistro.corr import *
+        LetsPlot.setup_html()
+        np.random.seed(42)
+        data = {var: np.random.normal(size=10) for var in 'abcdef'}
+        corr_plot(data, flip=False, threshold=.4).points().labels()\\
+            .palette_gradient(low='#d73027', mid='#ffffbf', high='#1a9850')\\
+            .build()
+
+    """
+
+    def _duplicate(self):
+        dup = corr_plot(
+            data=self._data,
+            show_legend=self._show_legend,
+            flip=self._reverse_y,
+            threshold=self.threshold
+        )
+
+        dup._color_scale = self._color_scale
+        dup._fill_scale = self._fill_scale
+        dup._points_params = self._points_params
+        dup._tiles_params = self._tiles_params
+        dup._labels_params = self._labels_params
+        dup._labels_map_size = self._labels_map_size
+        dup._palette = self._palette
+        dup._low = self._low
+        dup._mid = self._mid
+        dup._high = self._high
+
+        return dup
+
+    def __init__(self, data, show_legend=True, flip=True, threshold=None):
+        """
+        Parameters
+        ----------
+        data : dict or Pandas or Polars `DataFrame`
+            Correlation matrix or data (correlation will be calculated for each variable pair).
+            Data will be recognized as correlation matrix if it has a square shape and all values are
+            in range -1.0..+1.0 or NaN.
+        show_legend : bool, default=True
+            If True legend is shown.
+        flip : bool, default=True
+            If True the y axis is flipped.
+        threshold : float, default=0.0
+            Minimal correlation abs value to be included in result.
+            Accept values between 0 and 1.
+
+        """
+
+        self._data = data
+        self._show_legend = show_legend
+        self._reverse_y = flip if flip else False
+        self.threshold = threshold
+        self._color_scale = None
+        self._fill_scale = None
+        self._points_params = None
+        self._tiles_params = None
+        self._labels_params = None
+        self._labels_map_size = None
+        self._palette = None
+        self._low = None
+        self._mid = None
+        self._high = None
+
+    def points(self, type=None, diag=None):
+        """
+        Method defines correlation matrix layer drawn by points to the plot.
+
+        Parameters
+        ----------
+        type : {'upper', 'lower', 'full'}
+            Type of matrix. Default - contextual.
+        diag : bool
+            Determines whether to fill the main diagonal with values or not.
+            Default - contextual.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_points(type, diag)
+
+    def labels(self, type=None, diag=None, map_size=None, color=None):
+        """
+        Method defines correlation matrix layer drawn with geom_text to the plot.
+
+        Parameters
+        ----------
+        type : {'upper', 'lower', 'full'}
+            Type of matrix. Default - contextual.
+        diag : bool
+            Determines whether to fill the main diagonal with values or not.
+            Default - contextual.
+        map_size : bool
+            If True, then absolute value of correlation is mapped to text size.
+            If False - the text size is constant. Default - contextual.
+        color : str
+            Set text color.
+            For more info see `Color and Fill <https://lets-plot.org/python/pages/aesthetics.html#color-and-fill>`__.
+            Default - contextual.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_labels(type, diag, map_size, color)
+
+    def tiles(self, type=None, diag=None):
+        """
+        Method defines correlation matrix layer drawn as square tiles to the plot.
+
+        Parameters
+        ----------
+        type : {'upper', 'lower', 'full'}
+            Type of matrix. Default - contextual.
+        diag : bool
+            Determines whether to fill the main diagonal with values or not.
+            Default - contextual.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_tiles(type, diag)
+
+    def palette_gradient(self, low, mid, high):
+        """
+        Set `scale_color_gradient2()` and `scale_fill_gradient()` for corr plot.
+
+        Parameters
+        ----------
+        low : str
+            Color for low end of gradient (correlation -1).
+        mid : str
+            Color for mid point (correlation 0).
+        high : str
+            Color for high end of gradient (correlation 1).
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_gradient_palette(low, mid, high)
+
+    def palette_BrBG(self):
+        """
+        Set `scale_color_brewer()` with BrBG palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._set_brewer_palette('BrBG')
+
+    def palette_PiYG(self):
+        """
+        Set `scale_color_brewer()` with PiYG palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_brewer_palette('PiYG')
+
+    def palette_PRGn(self):
+        """
+        Set `scale_color_brewer()` with PRGn palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_brewer_palette('PRGn')
+
+    def palette_PuOr(self):
+        """
+        Set `scale_color_brewer()` with PuOr palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_brewer_palette('PuOr')
+
+    def palette_RdBu(self):
+        """
+        Set `scale_color_brewer()` with RdBu palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_brewer_palette('RdBu')
+
+    def palette_RdGy(self):
+        """
+        Set `scale_color_brewer()` with RdGy palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_brewer_palette('RdGy')
+
+    def palette_RdYlBu(self):
+        """
+        Set `scale_color_brewer()` with RdYlBu palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_brewer_palette('RdYlBu')
+
+    def palette_RdYlGn(self):
+        """
+        Set `scale_color_brewer()` with RdYlGn palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_brewer_palette('RdYlGn')
+
+    def palette_Spectral(self):
+        """
+        Set `scale_color_brewer()` with Spectral palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_brewer_palette('Spectral')
+
+    def _set_points(self, type=None, diag=None):
+        self._points_params = {'type': type, 'diag': diag, 'threshold': self.threshold}
+        return self
+
+    def _set_labels(self, type=None, diag=None, map_size=None, color=None):
+        self._labels_params = {'type': type, 'diag': diag, 'color': color, 'threshold': self.threshold}
+        self._labels_map_size = map_size
+        return self
+
+    def _set_tiles(self, type=None, diag=None):
+        self._tiles_params = {'type': type, 'diag': diag, 'threshold': self.threshold}
+        return self
+
+    def _set_gradient_palette(self, low, mid, high):
+        self._palette = 'gradient'
+        self._low = low
+        self._mid = mid
+        self._high = high
+        return self
+
+    def _set_brewer_palette(self, palette):
+        self._palette = palette
+        self._low = None
+        self._mid = None
+        self._high = None
+        return self
+
+    def build(self) -> PlotSpec:
+        """
+        This method creates PlotSpec object.
+
+        Returns
+        -------
+        `PlotSpec`
+            Plot specification.
+        """
+
+        if self._points_params is not None:
+            point_params = {
+                'type': self._points_params['type'],
+                'diag': self._points_params['diag']
+            }
+        else:
+            point_params = None
+
+        if self._labels_params is not None:
+            label_params = {
+                'type': self._labels_params['type'],
+                'diag': self._labels_params['diag'],
+                'color': self._labels_params['color'],
+                'map_size': self._labels_map_size
+            }
+        else:
+            label_params = None
+
+        if self._tiles_params is not None:
+            tile_params = {
+                'type': self._tiles_params['type'],
+                'diag': self._tiles_params['diag']
+            }
+        else:
+            tile_params = None
+
+        data = self._data
+        if _is_corr_matrix(data):
+            coefficients = True
+        else:
+            if is_pandas_data_frame(data):
+                data = data.corr(numeric_only=True)
+                coefficients = True
+            else:
+                coefficients = False
+
+        return PlotSpec(data=data, mapping=None, scales=[], layers=[], bistro={
+            'name': 'corr',
+            'coefficients': coefficients,
+            'show_legend': self._show_legend,
+            'flip': self._reverse_y,
+            'threshold': self.threshold,
+            'palette': self._palette,
+            'low': self._low,
+            'mid': self._mid,
+            'high': self._high,
+            'point_params': point_params,
+            'tile_params': tile_params,
+            'label_params': label_params
+        })