lessPython 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

lessPy/hier_plotly.py

@@ -19,15 +19,18 @@
 #     ported; fills default to BASE_COLORS keyed by top-level
 #     category (lessR's default "colors" theme). A sequential
 #     palette NAMED in fill= is ported (read by magnitude off the
-#     palette's ramp, R's pal_explicit branch). For the same
-#     reason the per-facet luminance remap (fill_vec_byfac) has
-#     no counterpart: every facet panel uses the global fills.
+#     palette's ramp, R's pal_explicit branch), and with facet=
+#     each panel reads its own shades off that ramp
+#     (fill_vec_byfac); other fills are the same in every panel.
 
 import numpy as np
 import pandas as pd
 import plotly.graph_objects as go
 
 from .getColors import _SEQ_NAMES
+
+# the palettes read by magnitude, R's seq.pals of .hier_color_resolve()
+_HIER_SEQ = set(_SEQ_NAMES) | {"terrain"}
 from .utils import STAT_FUN, get_option
 from .plotly_utils import (
     BASE_COLORS, facet_layout, plotly_style, to_hex,
@@ -160,6 +163,28 @@ def _seq_palette_fill(top_levels, pal, x, y, stat):
     return {lv: ramp[i] for lv, i in zip(top_levels, idx)}
 
 
+def hier_color_resolve_byfac(top_levels, fill, x, y, stat, facet,
+                             facet_order):
+    """Per-panel fills for a faceted chart: with a named sequential
+    palette, each panel's categories take their shades from that
+    panel's own counts (or stat of y), so each panel spans the
+    palette; None for any other fill, which every panel shares.
+    R analog: the fill_vec_byfac branch of .hier_color_resolve()"""
+    if not (isinstance(fill, str) and fill.lower() in _HIER_SEQ):
+        return None
+    fac = facet.astype(str)
+    out = {}
+    for lv in facet_order:
+        m = (fac == str(lv)).to_numpy()
+        present = set(x[m].astype(str))
+        tops = [t for t in top_levels if str(t) in present]
+        if tops:
+            out[str(lv)] = _seq_palette_fill(
+                tops, fill.lower(), x[m].astype(str),
+                None if y is None else y[m], stat)
+    return out
+
+
 def hier_color_resolve(top_levels, fill=None, x=None, y=None,
                        stat=None):
     """Hex color per top-level category, inherited down the tree.
@@ -169,7 +194,7 @@ def hier_color_resolve(top_levels, fill=None, x=None, y=None,
     ported."""
     if fill is None:
         fill = BASE_COLORS
-    if (isinstance(fill, str) and fill.lower() in _SEQ_NAMES
+    if (isinstance(fill, str) and fill.lower() in _HIER_SEQ
             and x is not None):
         return _seq_palette_fill(top_levels, fill.lower(), x, y,
                                  stat)
@@ -183,7 +208,7 @@ def hier_color_resolve(top_levels, fill=None, x=None, y=None,
             for i, lv in enumerate(top_levels)}
 
 
-def hier_plotly(agg, fill_vec, type="sunburst",
+def hier_plotly(agg, fill_vec, type="sunburst", fill_vec_byfac=None,
                 x_name="X", by_name=None, facet_name=None,
                 main=None, border=None, digits_d=None,
                 labels=None, labels_color="white",
@@ -254,8 +279,9 @@ def hier_plotly(agg, fill_vec, type="sunburst",
     if texttemplate is not None:
         kw["texttemplate"] = texttemplate
 
-    def make_trace(nd_i, dom_x, dom_y):
-        node_cols = [fill_vec.get(r, list(fill_vec.values())[0])
+    def make_trace(nd_i, dom_x, dom_y, cols=None):
+        cols = fill_vec if not cols else cols
+        node_cols = [cols.get(r, list(cols.values())[0])
                      for r in nd_i["root"]]
         return trace_cls(
             ids=nd_i["ids"],
@@ -334,8 +360,9 @@ def hier_plotly(agg, fill_vec, type="sunburst",
         for i, lv in enumerate(fac_levels):
             nd_i = nd_byfac[lv]
             if nd_i["ids"]:
-                fig.add_trace(make_trace(nd_i, domains[i]["x"],
-                                         domains[i]["y"]))
+                fig.add_trace(make_trace(
+                    nd_i, domains[i]["x"], domains[i]["y"],
+                    cols=(fill_vec_byfac or {}).get(str(lv))))
 
         t_margin = round(title_size * 2.8)
         fig.update_layout(

lessPy/hs_plotly.py

@@ -93,8 +93,8 @@ def hs_plotly(x, by=None, x_name=None, by_name=None,
 
     # groups need distinguishable hues: default to the palette
     if fill_miss and G > 1:
-        from .plotly_utils import BASE_COLORS
-        fill = BASE_COLORS
+        from .plotly_utils import by_colors
+        fill = by_colors(G)
 
     # --- counts per bin (right-closed bins, as in R's hist) ---
     def bin_counts(xg):
@@ -107,6 +107,18 @@ def hs_plotly(x, by=None, x_name=None, by_name=None,
         xg = xg[np.isfinite(xg)]
         y_mat[:, g] = bin_counts(pd.Series(xg))
 
+    # the bins as R's X() returns them
+    from .stats_out import record_stats
+    cnt = y_mat[:, 0] if G == 1 else pd.DataFrame(y_mat, columns=groups)
+    tot = cnt.sum() if G == 1 else cnt.sum(axis=0)
+    record_stats(bin_width=float(widths[0]), n_bins=n_bins,
+                 breaks=list(breaks), mids=mids.tolist(),
+                 counts=(cnt.astype(int).tolist() if G == 1
+                         else cnt.astype(int)),
+                 prop=(cnt / tot).tolist() if G == 1 else cnt / tot,
+                 cprop=(np.cumsum(cnt) / tot).tolist() if G == 1
+                 else cnt.cumsum() / tot)
+
     # density: normalize each group to unit area; proportion: to 1
     if not freq:
         for g in range(G):
@@ -287,8 +299,8 @@ def _hs_facet(x, facet, facet_order, x_name, facet_name, breaks,
 
     if fill is None:
         if G > 1:
-            from .plotly_utils import BASE_COLORS
-            fill = BASE_COLORS
+            from .plotly_utils import by_colors
+            fill = by_colors(G)
         else:
             fill = get_option("bar_fill_cont", "#96AAC3")
     if border is None:

lessPy/plotly_utils.py

@@ -17,6 +17,43 @@ BASE_COLORS = [
     "#00A3BA", "#D26FAF", "#00A76F", "#BD76CB",
 ]
 
+
+def theme_palette(theme=None):
+    """The palette a color theme gives to groups. R analog: .get_fill()
+    (not divergent): the qualitative hues for the default theme, else a
+    sequential palette in the theme's hue."""
+    from .utils import get_option
+    if theme is None:
+        theme = get_option("theme", "colors")
+    if theme == "colors":
+        return "hues"
+    for pal, members in (
+            ("grays", ("gray", "white")),
+            ("blues", ("lightbronze", "dodgerblue", "blue")),
+            ("browns", ("gold", "brown", "sienna")),
+            ("rusts", ("orange",)),
+            ("reds", ("darkred", "red", "rose", "slatered")),
+            ("greens", ("darkgreen", "green")),
+            ("violets", ("purple",))):
+        if theme in members:
+            return pal
+    return "blues"
+
+
+def by_colors(n, theme=None):
+    """One color per group of a by variable under the current theme,
+    as X() and XY() draw them. R analog: .color_range(.get_fill(theme),
+    n), two grays set apart as gray60 and gray30."""
+    pal = theme_palette(theme)
+    if pal == "hues":
+        return [BASE_COLORS[i % len(BASE_COLORS)] for i in range(n)]
+    if pal == "grays" and n == 2:
+        return ["#999999", "#4D4D4D"]
+    from .getColors import getColors
+    cols = getColors(pal, n=max(1, n), quiet=True)
+    return [c[:7] if len(c) == 9 else c for c in cols]
+
+
 # minimal named-color table; R's col2rgb() knows all R names, but
 # plotly accepts CSS names directly so unknowns pass through as-is
 _NAMED = {
@@ -80,6 +117,10 @@ def to_hex(col):
     gray = _gray_level(lower)
     if gray is not None:
         return gray
+    # any of R's named colors, as col2rgb() resolves them
+    from .rcolors import R_COLORS
+    if lower in R_COLORS:
+        return R_COLORS[lower]
     return c1        # CSS name unknown to us; plotly handles it
 
 
@@ -222,9 +263,13 @@ def legend_style(by_name, style_opts, title=None, position=None,
     leg = dict(
         title=dict(text=abbrev(text, abbrev_n) or "",
                    font=dict(size=round(
-                       15 * get_option("lab_size", 1) * mult))),
+                       15 * get_option("lab_size", 1) * mult),
+                       color=to_hex(style_opts["lab_color"]))),
+        # the legend reads in the theme's label color, light on the
+        #   black sub_theme as the axis labels are
         font=dict(size=round(
-            16 * get_option("axis_size", 0.9) * mult)),
+            16 * get_option("axis_size", 0.9) * mult),
+            color=to_hex(style_opts["lab_color"])),
         bgcolor=to_hex(style_opts["window_fill"]),
         bordercolor=to_hex(style_opts["legend_border"]),
         borderwidth=1,
@@ -316,9 +361,13 @@ def axis_format(vals, digits_d=2, axis_fmt="K", prefix=""):
 
 
 def grid_style():
-    """R analog: .grid_style()"""
+    """R analog: .grid_style(). A sub_theme sets the grid through
+    grid_x_color / grid_y_color (white on the gray panel of "default"),
+    which take precedence over the grid color itself"""
+    clr = (get_option("grid_y_color") or get_option("grid_x_color")
+           or get_option("grid_col", "gray85"))
     return {
-        "color": to_hex(get_option("grid_col", "gray85")),
+        "color": to_hex(clr),
         "width": get_option("grid_lwd", 0.5),
         "dash": get_option("grid_lty", None),
     }
@@ -355,17 +404,26 @@ def y_grid(y_vals):
 
 
 def axis_base():
-    """R analog: axis_base()"""
+    """R analog: axis_base(). A sub_theme sets the axes through their
+    own settings, so on sub_theme="black" the axis line and its labels
+    are light where axis_color stays dark; the labels are text, so they
+    take axis_text_color, as lessR's base R axes do"""
+    ax_line = (get_option("axis_x_color")
+               or get_option("axis_color", "black"))
+    ax_text = (get_option("axis_x_text_color")
+               or get_option("axis_text_color")
+               or get_option("axis_color", "black"))
     return {
         "zeroline": False,
         "showline": True,
-        "linecolor": to_hex(get_option("axis_color", "black")),
+        "linecolor": to_hex(ax_line),
         "linewidth": get_option("axis_lwd", 1),
         "ticks": "outside",
         "ticklen": 4,
+        "tickcolor": to_hex(ax_line),
         "automargin": True,
         "tickfont": {
-            "color": to_hex(get_option("axis_color", "black")),
+            "color": to_hex(ax_text),
             "size": 16 * get_option("axis_size", 0.9),
         },
         "title": {
@@ -486,6 +544,10 @@ def font_scaled(func):
         fig = func(*args, **kwargs)
         if sub and hasattr(fig, "layout"):
             add_subtitle(fig, sub)
+        # style(font_family=) sets the family of all plotted text
+        family = get_option("font_family")
+        if family and hasattr(fig, "layout"):
+            fig.update_layout(font=dict(family=family))
         try:
             if font_size and font_size != 1 and hasattr(fig, "layout"):
                 apply_font_size(fig, font_size)
@@ -603,7 +665,7 @@ def facet_panels(facet, facet_order, facet2=None,
 
 def finish_facet(fig, levels, ax, x_lab, y_lab, gridT1,
                  style_opts=None, y_cat=None, n_col=1, pos=None,
-                 height=None, width=None):
+                 height=None, width=None, x_cat=None):
     """Facet styling shared by the faceted renderers: per-panel y
     axes on a common scale (y label on the middle panel of the
     first column), x ticks on the bottom row only, vertical grid
@@ -670,7 +732,14 @@ def finish_facet(fig, levels, ax, x_lab, y_lab, gridT1,
                       showticklabels=c == 1)
         fig.update_yaxes(row=r, col=c, **ay)
         lowest = r == n_row or (r + 1, c) not in occupied
-        if lowest:
+        if lowest and x_cat is not None:
+            # categories along x, the vertical bars of a panel
+            ax_x = axis_cat(x_lab if c == mid_c else "")
+            ax_x.update(categoryorder="array",
+                        categoryarray=list(x_cat), tickmode="array",
+                        tickvals=list(x_cat), ticktext=list(x_cat))
+            fig.update_xaxes(row=r, col=c, showticklabels=True, **ax_x)
+        elif lowest:
             # a shared x axis hides the labels above the bottom row,
             #   so a ragged grid's lowest panel turns its own back on
             fig.update_xaxes(

lessPy/plt_mat_plotly.py

@@ -29,14 +29,28 @@ def _axis_ref(k, kind):
 
 
 def scatter_matrix(df, fit="lm", digits_d=2, cor_coef=True,
-                   main=None, band=True):
+                   main=None, band=True, form="scatter",
+                   contour_n=None, contour_nbins=50,
+                   contour_points=False, smooth_bins=128,
+                   smooth_power=0.25):
     """Scatterplot matrix of the columns of df, in column order.
     fit: "off" (no line, XY default), "lm" (Regression) or
     "loess". cor_coef=True puts the correlation in the upper
     triangle and the scatter below (~ .plt.mat, Regression);
     cor_coef=False draws the scatter in every off-diagonal cell,
     the symmetric matrix R's Logit uses (logit.4Pred). band adds
-    the fit's 95% confidence band. Returns a plotly Figure."""
+    the fit's 95% confidence band. form="contour" or "smooth"
+    draws each cell as its own kernel density over the cell's
+    range, 8 contour bands unless contour_n is given (a cell cannot
+    resolve the 20 of a single plot), any fit drawn without its
+    band. R analog: .plt.mat() panel.dens. Returns a plotly
+    Figure."""
+    if form not in ("scatter", "contour", "smooth"):
+        raise ValueError(
+            'A matrix renders its cells as form="scatter", "contour", '
+            f'or "smooth", so form="{form}" is not\navailable for a '
+            "matrix.")
+    contour_n = 8 if contour_n is None else int(contour_n)
     cols = list(df.columns)
     n = len(cols)
     if n < 2:
@@ -78,6 +92,17 @@ def scatter_matrix(df, fit="lm", digits_d=2, cor_coef=True,
 
             # scatter in the lower triangle, and also in the
             # upper triangle when no correlations are requested
+            if r != c and (r > c or not cor_coef) \
+                    and form != "scatter":
+                _cell_bg(fig, xr, yr, bg, border)
+                _density_cell(fig, r, c, vals[cols[c - 1]],
+                              vals[cols[r - 1]], rng[cols[c - 1]],
+                              rng[cols[r - 1]], form, contour_n,
+                              contour_nbins, contour_points,
+                              smooth_bins, smooth_power,
+                              fit if do_fit else "off", fit_color,
+                              fit_lwd)
+                continue
             if r != c and (r > c or not cor_coef):
                 _cell_bg(fig, xr, yr, bg, border)
                 _scatter_cell(fig, r, c, vals[cols[c - 1]],
@@ -199,3 +224,50 @@ def _scatter_cell(fig, r, c, xv, yv, fit, do_fit, px,
             x=xs, y=f, mode="lines",
             line=dict(color=fit_color, width=fit_lwd),
             hoverinfo="skip", showlegend=False), row=r, col=c)
+
+
+def _density_cell(fig, r, c, xv, yv, xr, yr, form, contour_n,
+                  contour_nbins, contour_points, smooth_bins,
+                  smooth_power, fit, fit_color, fit_lwd):
+    """One cell as a kernel density over the cell's range: filled
+    contour bands or the smooth shading, then the fit, unbanded.
+    R analog: panel.dens of .plt.mat()"""
+    from .plt_contour import _COLORSCALE, _bw_nrd, _kde2d
+    from .plt_smooth import _RAMP
+    from .XY import _loess, _plt_fit
+
+    ok = np.isfinite(xv) & np.isfinite(yv)
+    xo, yo = xv[ok], yv[ok]
+    if len(xo) < 3 or _bw_nrd(xo) <= 0 or _bw_nrd(yo) <= 0:
+        return
+    lims = (float(xr[0]), float(xr[-1]), float(yr[0]), float(yr[-1]))
+    n_grid = smooth_bins if form == "smooth" else contour_nbins
+    gx, gy, z = _kde2d(xo, yo, n_grid, lims)
+    if form == "smooth":
+        fig.add_trace(go.Heatmap(
+            x=gx, y=gy, z=(z ** smooth_power).T, colorscale=_RAMP,
+            zsmooth="best", showscale=False, hoverinfo="skip"),
+            row=r, col=c)
+    else:
+        lv0, lv1 = float(z.min()), float(z.max())
+        step = (lv1 - lv0) / contour_n
+        fig.add_trace(go.Contour(
+            x=gx, y=gy, z=z.T, colorscale=_COLORSCALE,
+            contours=dict(start=lv0 + step, end=lv1, size=step),
+            line=dict(width=0), showscale=False, hoverinfo="skip"),
+            row=r, col=c)
+        if contour_points:
+            fig.add_trace(go.Scatter(
+                x=xo, y=yo, mode="markers",
+                marker=dict(size=3, color="rgba(0,0,0,0.27)",
+                            line=dict(color="white", width=0.2)),
+                hoverinfo="skip", showlegend=False), row=r, col=c)
+    if fit in ("lm", "loess"):
+        if fit == "loess":
+            xs, _, f, _ = _loess(xo, yo, 2 / 3)
+        else:
+            xs, _, f = _plt_fit(xo, yo, "lm", 1)
+        fig.add_trace(go.Scatter(
+            x=xs, y=f, mode="lines",
+            line=dict(color=fit_color, width=fit_lwd),
+            hoverinfo="skip", showlegend=False), row=r, col=c)

lessPy/plt_time.py

@@ -56,11 +56,18 @@ def _agg_one(dser, yser, ts_unit, aggfun):
         per = dser
     else:
         per = dser.dt.to_period(_PERIOD_FREQ[ts_unit])
-        # trailing partial period: last date short of period end
+        # trailing partial period: its last date short of the period
+        # end AND fewer observations than the median of the earlier
+        # periods, so data dated at period starts keeps its complete
+        # final period. R analog: ts_truncate() (plt.time.R)
         last_per = per.iloc[int(np.argmax(dser.to_numpy()))]
         if dser.max() < last_per.end_time.normalize():
-            keep = (per != last_per).to_numpy()
-            dser, yser, per = dser[keep], yser[keep], per[keep]
+            n_per = per.value_counts()
+            others = n_per.drop(last_per)
+            n_full = float(np.median(others)) if len(others) else 0
+            if n_per[last_per] < n_full:
+                keep = (per != last_per).to_numpy()
+                dser, yser, per = dser[keep], yser[keep], per[keep]
     if len(dser) == 0:
         return (np.array([], dtype="datetime64[ns]"),
                 np.array([]))

lessPy/prob_norm.py

@@ -8,7 +8,7 @@
 
 import numpy as np
 
-from .utils import fmt
+from .utils import fmt, show_plots
 
 _FILL_NRM = "#E8E8E8"      # grey91
 _FILL_INT = "#9FB6CD"      # slategray3
@@ -57,8 +57,8 @@ def prob_norm(lo=None, hi=None, mu=0, sigma=1, nrm_color="black",
 
     print(f"Probability:  {prob}")
 
-    return ProbNormResults(prob=prob, lo=lo_v, hi=hi_v, mu=mu,
-                           sigma=sigma, plots={"norm": fig})
+    return show_plots(ProbNormResults(prob=prob, lo=lo_v, hi=hi_v, mu=mu,
+                           sigma=sigma, plots={"norm": fig}))
 
 
 def _plot(lo, hi, lo_lbl, hi_lbl, mu, sigma, prob, nrm_color,

lessPy/prob_tcut.py

@@ -9,7 +9,7 @@
 
 import numpy as np
 
-from .utils import fmt
+from .utils import fmt, show_plots
 
 _BG = "#F9F9FC"             # rgb(249,249,252)
 _TAIL = "#8B475D"           # palevioletred4
@@ -51,8 +51,8 @@ def prob_tcut(df, alpha=0.05, digits_d=3, y_axis=False,
                 fill, color_tail, nrm_color, color_t)
 
     print(f"Probability:  {cutoff}")
-    return ProbTcutResults(cutoff=cutoff, df=df, alpha=alpha,
-                           plots={"tcut": fig})
+    return show_plots(ProbTcutResults(cutoff=cutoff, df=df, alpha=alpha,
+                           plots={"tcut": fig}))
 
 
 def _cut_line(fig, x, top, color):

lessPy/prob_znorm.py

@@ -11,6 +11,8 @@
 
 import numpy as np
 
+from .utils import show_plots
+
 
 class ProbZnormResults:
     """Result of prob_znorm(): mu/sigma and the plotly figure in
@@ -46,7 +48,7 @@ def prob_znorm(mu=0, sigma=1, color_border="gray10", r=0.10,
            f"{round(b * 255)},{a})"
 
     fig = _plot(mu, sigma, border, fill, main, y_axis, z)
-    return ProbZnormResults(mu=mu, sigma=sigma, plots={"znorm": fig})
+    return show_plots(ProbZnormResults(mu=mu, sigma=sigma, plots={"znorm": fig}))
 
 
 def _gray_to_hex(color):