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

lessPy/details.py

@@ -129,6 +129,11 @@ def details(data=None, n_mcut=1, max_lines=30, miss_show=30,
 
     names = list(data.columns)
     types = [_type_label(data[c]) for c in names]
+    # whole numbers that pandas stores as float64 (a pandas integer
+    # column cannot hold NaN): reported as integer, as lessR does,
+    # but flagged so the report states what pandas actually stores
+    stored_float = [t == "integer" and pdt.is_float_dtype(data[c].dtype)
+                    for c, t in zip(names, types)]
     n_val = [int(data[c].notna().sum()) for c in names]
     n_miss = [int(data[c].isna().sum()) for c in names]
     n_uniq = [int(data[c].dropna().nunique()) for c in names]
@@ -137,7 +142,8 @@ def details(data=None, n_mcut=1, max_lines=30, miss_show=30,
     _print_types(types)
     first_last = [_first_last(data[c], n_obs) for c in names]
     maybe_id, id_col = _print_table(names, types, n_val, n_miss,
-                                    n_uniq, first_last, n_var)
+                                    n_uniq, first_last, n_var,
+                                    stored_float)
 
     if maybe_id is not None and not var_labels:
         _print_id_note(maybe_id, id_col)
@@ -196,10 +202,13 @@ def _print_types(types):
 
 
 def _print_table(names, types, n_val, n_miss, n_uniq, first_last,
-                 n_var):
+                 n_var, stored_float=None):
+    if stored_float is None:
+        stored_float = [False] * n_var
+    shown = [t + "*" if f else t for t, f in zip(types, stored_float)]
     w_num = max(2, len(str(n_var)))
     w_nam = max(len("Variable"), *(len(x) for x in names))
-    w_typ = max(len("Type"), *(len(t) for t in types))
+    w_typ = max(len("Type"), *(len(t) for t in shown))
     w_val = max(len("Values"), *(len(str(x)) for x in n_val))
     w_mis = max(len("Missing"), *(len(str(x)) for x in n_miss))
     w_uni = max(len("Unique"), *(len(str(x)) for x in n_uniq))
@@ -215,7 +224,7 @@ def _print_table(names, types, n_val, n_miss, n_uniq, first_last,
     maybe_id, id_col = None, 0
     for i in range(n_var):
         print(f"{i + 1:>{w_num}}  {names[i]:<{w_nam}}  "
-              f"{types[i]:<{w_typ}}  {n_val[i]:>{w_val}}  "
+              f"{shown[i]:<{w_typ}}  {n_val[i]:>{w_val}}  "
               f"{n_miss[i]:>{w_mis}}  {n_uniq[i]:>{w_uni}}  "
               f"{first_last[i]}")
         if (n_uniq[i] == n_val[i]
@@ -223,6 +232,10 @@ def _print_table(names, types, n_val, n_miss, n_uniq, first_last,
                                  "character")):
             maybe_id, id_col = names[i], i + 1
     _dash(len(hdr))
+    if any(stored_float):
+        print("* Whole numbers stored by Pandas as float64 (double), "
+              "usually because\n  the column had missing values, NaN, "
+              "which a Pandas integer column\n  cannot hold.")
     return maybe_id, id_col
 
 

lessPy/dn_plotly.py

@@ -58,11 +58,13 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
         from .utils import bw_nrd0
         bw = bw_nrd0(x)
     h = bw * adjust
+    from .stats_out import record_stats
+    record_stats(bw=float(h))
 
     if facet is not None:
         if fill_miss and by is not None:
-            from .plotly_utils import BASE_COLORS
-            fill = BASE_COLORS
+            from .plotly_utils import by_colors
+            fill = by_colors(len(pd.Series(by).dropna().unique()))
         return _dn_facet(x, facet, facet_order, x_name,
                          facet_name, fill, x_lab, y_lab, main,
                          h, n, fill_area, style_opts,
@@ -91,8 +93,8 @@ def dn_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)
 
     def group_x(gname):
         xg = x if by is None else x[(by == gname).to_numpy()]
@@ -124,6 +126,11 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
     dx = grid[1] - grid[0]
 
     # --- densities per group -------------------------------------
+    # R analog: dn.plotly.R — kind "normal"/"both" adds the normal
+    # fit to each group by its own mean and sd on the shared grid;
+    # a group of identical values has no normal to draw
+    do_gen = kind in ("general", "both")
+    do_nrm = kind in ("normal", "both")
     dens = []
     ymax = 0.0
     for gname in groups:
@@ -133,19 +140,21 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
             [[0], np.cumsum((y[1:] + y[:-1]) * 0.5 * dx)])
         if cum[-1] > 0:
             cum = cum / cum[-1]
-        dens.append(dict(y=y, cum=cum, mn=float(xg.mean())))
-        ymax = max(ymax, float(y.max()))
-
-    # --- normal curve and background histogram --------------------
-    # R analog: dn.main.R — kind "normal"/"both" adds the normal
-    # curve at the sample mean and sd; show_histogram draws a
-    # faint density-scaled histogram behind the curves
-    d_nrm = None
-    if kind in ("normal", "both"):
-        xg0 = group_x(groups[0])
-        mu, sd = float(xg0.mean()), float(xg0.std(ddof=1))
-        z = (grid - mu) / sd
-        d_nrm = np.exp(-0.5 * z * z) / (sd * np.sqrt(2 * np.pi))
+        sd = float(xg.std(ddof=1))
+        nrm = None
+        if do_nrm and np.isfinite(sd) and sd > 0:
+            z = (grid - float(xg.mean())) / sd
+            nrm = np.exp(-0.5 * z * z) / (sd * np.sqrt(2 * np.pi))
+        dens.append(dict(y=y, cum=cum, mn=float(xg.mean()), nrm=nrm))
+        # only a curve that is drawn sets the height of the y-axis
+        if do_gen:
+            ymax = max(ymax, float(y.max()))
+        if nrm is not None:
+            ymax = max(ymax, float(nrm.max()))
+
+    # --- background histogram -------------------------------------
+    # show_histogram draws a faint density-scaled histogram behind
+    # the curves (dn.main.R)
     hist_y = None
     if show_histogram and hist_edges is not None:
         e = np.asarray(hist_edges, dtype=float)
@@ -155,10 +164,6 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
             hist_w = np.diff(e)
             hist_y = cnt / (tot * hist_w)  # density scale
             hist_mids = (e[:-1] + e[1:]) / 2
-    if kind == "normal":               # general curve not drawn
-        ymax = 0.0
-    if d_nrm is not None:
-        ymax = max(ymax, float(d_nrm.max()))
     if hist_y is not None:
         ymax = max(ymax, float(hist_y.max()))
 
@@ -195,12 +200,16 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
                 if fill_hist is None else fill_hist),
                 line=dict(width=0)),
             hoverinfo="skip", showlegend=False))
-    if kind in ("general", "both"):
-        for g, gname in enumerate(groups):
-            d = dens[g]
-            hv = hover(d)
-            if G > 1 and by_name:
-                hv = [f"{by_name}: {gname}<br>{t}" for t in hv]
+    # the normal curve: its own color for a single distribution, but
+    # the group's color when there are groups to keep apart, dashed
+    # beside that group's general curve (dn.plotly.R)
+    nrm_fill = (None if fill_normal in (None, "transparent")
+                else as_plotly_color(fill_normal))
+    for g, gname in enumerate(groups):
+        d = dens[g]
+        pre = (f"{by_name}: {gname}<br>"
+               if G > 1 and by_name else "")
+        if do_gen:
             fig.add_trace(go.Scatter(
                 mode="lines",
                 x=grid, y=d["y"],
@@ -209,29 +218,40 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
                 fill="tozeroy" if fill_area else "none",
                 fillcolor=fill_rgba[g] if fill_area else None,
                 hoverinfo="text",
-                hovertext=hv,
+                hovertext=[pre + t for t in hover(d)],
                 showlegend=G > 1,
             ))
-            # vertical line at the group mean, up to the curve
-            y_mn = float(np.interp(d["mn"], grid, d["y"]))
-            mean_line = dict(color=line_rgba[g], dash="dash",
-                             width=1.4 if fill_area else 0.7)
+        if d["nrm"] is not None:
+            nrm_col = line_rgba[g] if G > 1 else to_hex(color_normal)
+            filled = fill_area and G == 1 and nrm_fill is not None
             fig.add_trace(go.Scatter(
-                mode="lines",
-                x=[d["mn"], d["mn"]], y=[0, y_mn],
-                line=mean_line,
-                hoverinfo="skip", showlegend=False,
+                mode="lines", x=grid, y=d["nrm"],
+                name=(None if G == 1 else
+                      f"{gname} normal" if do_gen else gname),
+                showlegend=G > 1 and not do_gen,
+                line=dict(color=nrm_col, width=1.4,
+                          dash="dash" if do_gen and G > 1
+                          else "solid"),
+                fill="tozeroy" if filled else "none",
+                fillcolor=nrm_fill if filled else None,
+                hoverinfo="text",
+                hovertext=[
+                    f"{pre}{x_name}: {grid[i]:.6g}"
+                    f"<br>Normal density="
+                    f"{round(float(d['nrm'][i]), 6):g}"
+                    for i in range(n)],
             ))
-    if d_nrm is not None:              # normal curve
-        nrm_fill = (None if fill_normal in (None, "transparent")
-                    else as_plotly_color(fill_normal))
+        # vertical line at the group mean, up to whichever curve
+        # is drawn
+        curve = d["y"] if do_gen or d["nrm"] is None else d["nrm"]
+        y_mn = float(np.interp(d["mn"], grid, curve))
         fig.add_trace(go.Scatter(
-            mode="lines", x=grid, y=d_nrm,
-            line=dict(color=to_hex(color_normal),
-                      width=1.35 if nrm_fill is None else 1),
-            fill="none" if nrm_fill is None else "tozeroy",
-            fillcolor=nrm_fill,
-            hoverinfo="skip", showlegend=False))
+            mode="lines",
+            x=[d["mn"], d["mn"]], y=[0, y_mn],
+            line=dict(color=line_rgba[g], dash="dash",
+                      width=1.4 if fill_area else 0.7),
+            hoverinfo="skip", showlegend=False,
+        ))
     if rug:                            # ticks at each data value
         xr, yr = [], []
         y1r = -0.05 * ymax
@@ -240,7 +260,7 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
             yr += [0.0, y1r, None]
         fig.add_trace(go.Scatter(
             mode="lines", x=xr, y=yr,
-            line=dict(color=to_hex(color_rug),
+            line=dict(color=as_plotly_color(color_rug),
                       width=max(0.5, float(size_rug))),
             hoverinfo="skip", showlegend=False))
 
@@ -250,12 +270,12 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
         axis_shapes = [dict(
             type="line", xref="paper", yref="paper",
             x0=0, x1=1, y0=0, y1=0,
-            line=dict(color=to_hex("gray50"), width=1))]
+            line=dict(color=as_plotly_color("gray50"), width=1))]
 
     ax_x = axis_num(x_lab, gridT1, gridL1)
     ax_y = axis_num(y_lab, gridT2, gridL2)
     ax_y.update(showgrid=True,
-                gridcolor=to_hex(style_opts["grid_col"]),
+                gridcolor=as_plotly_color(style_opts["grid_col"]),
                 gridwidth=1, griddash="dot")
 
     fig.update_layout(
@@ -264,8 +284,8 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
         shapes=x_grid(gridT1) + plot_border() + axis_shapes,
         template=None,
         bargap=0,
-        plot_bgcolor=to_hex(style_opts["panel_fill"]),
-        paper_bgcolor=to_hex(style_opts["window_fill"]),
+        plot_bgcolor=as_plotly_color(style_opts["panel_fill"]),
+        paper_bgcolor=as_plotly_color(style_opts["window_fill"]),
     )
 
     if G > 1:
@@ -277,7 +297,7 @@ def dn_plotly(x, by=None, x_name=None, by_name=None,
             title=dict(text=main, x=0.5, xanchor="center",
                        y=0.99, yanchor="top",
                        font=dict(size=title_size,
-                                 color=to_hex(get_option(
+                                 color=as_plotly_color(get_option(
                                      "lab_color", "black")))),
             margin=dict(t=round(title_size * 2.2)))
     return fig
@@ -455,7 +475,7 @@ def _dn_facet(x, facet, facet_order, x_name, facet_name, fill,
                         else as_plotly_color(fill_normal))
             fig.add_trace(go.Scatter(
                 mode="lines", x=grid, y=d_nrms[i],
-                line=dict(color=to_hex(color_normal),
+                line=dict(color=as_plotly_color(color_normal),
                           width=1.35 if nrm_fill is None else 1),
                 fill="none" if nrm_fill is None else "tozeroy",
                 fillcolor=nrm_fill,
@@ -469,7 +489,7 @@ def _dn_facet(x, facet, facet_order, x_name, facet_name, fill,
                 yr += [0.0, y1r, None]
             fig.add_trace(go.Scatter(
                 mode="lines", x=xr, y=yr,
-                line=dict(color=to_hex(color_rug),
+                line=dict(color=as_plotly_color(color_rug),
                           width=max(0.5, float(size_rug))),
                 hoverinfo="skip", showlegend=False,
             ), row=row, col=p_col)
@@ -489,7 +509,7 @@ def _dn_facet(x, facet, facet_order, x_name, facet_name, fill,
             title=dict(text=main, x=0.5, xanchor="center",
                        y=0.99, yanchor="top",
                        font=dict(size=title_size,
-                                 color=to_hex(get_option(
+                                 color=as_plotly_color(get_option(
                                      "lab_color", "black")))),
             margin=dict(t=round(title_size * 2.2)))
     return fig

lessPy/dot_plotly.py

@@ -19,6 +19,7 @@ import plotly.graph_objects as go
 
 from .utils import get_option
 from .plotly_utils import (
+    as_plotly_color,
     BASE_COLORS, axis_cat, axis_format, axis_num, facet_layout,
     get_tick_fmt, make_trans, plot_border, plotly_style, to_hex,
     x_grid, y_grid,
@@ -128,7 +129,7 @@ def _dot_title(main):
     return dict(text=main, x=0.5, xanchor="center",
                 y=0.98, yanchor="top",
                 font=dict(size=round(16 * get_option("main_size", 1)),
-                          color=to_hex(get_option("lab_color",
+                          color=as_plotly_color(get_option("lab_color",
                                                   "black"))))
 
 
@@ -169,7 +170,7 @@ def dot_plotly(x, y, orientation="v",
             else np.asarray(list(vals), dtype=float))
     flat = flat[np.isfinite(flat)]
     val_max = float(flat.max()) if flat.size else None
-    seg_color = to_hex(style_opts["segment_color"])
+    seg_color = as_plotly_color(style_opts["segment_color"])
 
     def val_ticks(orient):
         # value-axis labels through the axis_fmt policies ("60K"),
@@ -240,8 +241,8 @@ def dot_plotly(x, y, orientation="v",
                 font=dict(size=round(
                     16 * get_option("axis_size", 0.9)))),
             template=None,
-            plot_bgcolor=to_hex(style_opts["panel_fill"]),
-            paper_bgcolor=to_hex(style_opts["window_fill"]),
+            plot_bgcolor=as_plotly_color(style_opts["panel_fill"]),
+            paper_bgcolor=as_plotly_color(style_opts["window_fill"]),
         )
         return fig
 
@@ -374,8 +375,8 @@ def dot_plotly(x, y, orientation="v",
                     16 * get_option("axis_size", 0.9)))),
             title=_dot_title(main),
             template=None,
-            plot_bgcolor=to_hex(style_opts["panel_fill"]),
-            paper_bgcolor=to_hex(style_opts["window_fill"]),
+            plot_bgcolor=as_plotly_color(style_opts["panel_fill"]),
+            paper_bgcolor=as_plotly_color(style_opts["window_fill"]),
             **axes,
         )
         return fig
@@ -450,7 +451,7 @@ def dot_plotly(x, y, orientation="v",
         margin=margin,
         title=_dot_title(main),
         template=None,
-        plot_bgcolor=to_hex(style_opts["panel_fill"]),
-        paper_bgcolor=to_hex(style_opts["window_fill"]),
+        plot_bgcolor=as_plotly_color(style_opts["panel_fill"]),
+        paper_bgcolor=as_plotly_color(style_opts["window_fill"]),
     )
     return fig

lessPy/freq_poly_plotly.py

@@ -25,7 +25,7 @@ import plotly.graph_objects as go
 
 from .utils import get_option, pretty
 from .plotly_utils import (
-    auto_opacity, axis_format, axis_num, facet_fig,
+    as_plotly_color, auto_opacity, axis_format, axis_num, facet_fig,
     facet_panels, finish_facet, get_tick_fmt,
     legend_style, make_trans, plot_border, plotly_style, to_hex,
     x_grid,
@@ -48,6 +48,7 @@ def freq_poly_plotly(x, by=None, x_name=None, by_name=None,
                      facet2=None, facet2_order=None,
                      facet2_name=None,
                      breaks=None, proportion=False,
+                     cumulate=False,
                      fill=None, fill_area=True,
                      x_lab=None, y_lab=None, main=None,
                      n_col=1, axis_fmt="K", axis_x_pre="",
@@ -65,6 +66,8 @@ def freq_poly_plotly(x, by=None, x_name=None, by_name=None,
     if y_lab is None:
         y_lab = (f"Proportion of {x_name}" if proportion
                  else f"Count of {x_name}")
+        if cumulate:
+            y_lab = f"Cumulative {y_lab}"
 
     if facet is not None:
         return _fp_facet(x, facet, facet_order, x_name,
@@ -90,8 +93,8 @@ def freq_poly_plotly(x, by=None, x_name=None, by_name=None,
     # groups need distinguishable hues: default to the palette
     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")
 
@@ -107,6 +110,8 @@ def freq_poly_plotly(x, by=None, x_name=None, by_name=None,
         xg = x if by is None else x[(by == gname).to_numpy()]
         xg = xg[np.isfinite(xg)]
         yv = _poly_counts(xg, breaks, proportion)
+        if cumulate:                   # running total over the bins
+            yv = np.cumsum(yv)
         polys.append(yv)
         ymax = max(ymax, float(yv.max()))
 
@@ -133,7 +138,9 @@ def freq_poly_plotly(x, by=None, x_name=None, by_name=None,
     for g, gname in enumerate(groups):
         xx = np.concatenate([[mids[0] - step], mids,
                              [mids[-1] + step]])
-        yy = np.concatenate([[0], polys[g], [0]])
+        # a cumulative polygon (ogive) holds its total at the right
+        yy = np.concatenate([[0], polys[g],
+                             [polys[g][-1] if cumulate else 0]])
         hover = [
             (f"{x_name}: {xv:.6g}"
              f"<br>{y_lab}: {round(float(yv), digits_d):g}")
@@ -162,7 +169,7 @@ def freq_poly_plotly(x, by=None, x_name=None, by_name=None,
     ax_x = axis_num(x_lab, gridT1, gridL1)
     ax_y = axis_num(y_lab, gridT2, gridL2)
     ax_y.update(showgrid=True,
-                gridcolor=to_hex(style_opts["grid_col"]),
+                gridcolor=as_plotly_color(style_opts["grid_col"]),
                 gridwidth=1, griddash="dot")
 
     fig.update_layout(
@@ -170,8 +177,8 @@ def freq_poly_plotly(x, by=None, x_name=None, by_name=None,
         yaxis=ax_y,
         shapes=x_grid(gridT1) + plot_border(),
         template=None,
-        plot_bgcolor=to_hex(style_opts["panel_fill"]),
-        paper_bgcolor=to_hex(style_opts["window_fill"]),
+        plot_bgcolor=as_plotly_color(style_opts["panel_fill"]),
+        paper_bgcolor=as_plotly_color(style_opts["window_fill"]),
     )
 
     if G > 1:
@@ -183,7 +190,7 @@ def freq_poly_plotly(x, by=None, x_name=None, by_name=None,
             title=dict(text=main, x=0.5, xanchor="center",
                        y=0.99, yanchor="top",
                        font=dict(size=title_size,
-                                 color=to_hex(get_option(
+                                 color=as_plotly_color(get_option(
                                      "lab_color", "black")))),
             margin=dict(t=round(title_size * 2.2)))
     return fig
@@ -221,8 +228,8 @@ def _fp_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")
 
@@ -318,7 +325,7 @@ def _fp_facet(x, facet, facet_order, x_name, facet_name, breaks,
             title=dict(text=main, x=0.5, xanchor="center",
                        y=0.99, yanchor="top",
                        font=dict(size=title_size,
-                                 color=to_hex(get_option(
+                                 color=as_plotly_color(get_option(
                                      "lab_color", "black")))),
             margin=dict(t=round(title_size * 2.2)))
     return fig