lets-plot 4.8.0rc1__cp313-cp313-macosx_12_0_arm64.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.8.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,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