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

lessPy/stats_out.py

@@ -32,11 +32,17 @@ def x_stats(xv, x_name, digits_d=2):
     lines = [f"--- {x_name} ---",
              f"n: {n}   missing: {miss}"]
     if n < 2:
+        record_stats(n=n, n_miss=miss)
         return lines
     q1, med, q3 = np.percentile(v, [25, 50, 75])
     iqr = q3 - q1
     out_v = np.sort(v[(v < q1 - 1.5 * iqr)
                       | (v > q3 + 1.5 * iqr)])
+    record_stats(n=n, n_miss=miss, mean=float(v.mean()),
+                 sd=float(v.std(ddof=1)), min=float(v.min()),
+                 q1=float(q1), median=float(med), q3=float(q3),
+                 max=float(v.max()), iqr=float(iqr),
+                 outliers=out_v.tolist())
     lines += [
         f"mean: {fmt(v.mean(), d)}   sd: {fmt(v.std(ddof=1), d)}",
         f"min: {fmt(v.min(), d)}   1st Qu: {fmt(q1, d)}   "
@@ -94,29 +100,70 @@ def _cor_block(xg, yg, label, d):
 
 
 def xy_stats(groups, x_name, y_name, fit_stats=None,
-             digits_d=2):
+             digits_d=2, by_name=None):
     """Correlation (t test, Fisher-z CI) for the relationship
     XY() displays, overall or per by= group, plus fit-line MSE
     when a fit line is drawn."""
     lines = [f"--- {x_name} and {y_name} ---"]
+    cors = {}
     for nm, xg, yg in groups:
         label = "" if nm is None else f" ({nm})"
-        lines += _cor_block(np.asarray(xg, float),
-                            np.asarray(yg, float), label,
-                            digits_d)
+        xg, yg = np.asarray(xg, float), np.asarray(yg, float)
+        lines += _cor_block(xg, yg, label, digits_d)
+        cors[nm] = _cor_values(xg, yg)
+    fits = []
     for fs in (fit_stats or []):
-        nm, fit, ys, f = fs
+        nm, fit, ys, f = fs[:4]
+        xs = fs[4] if len(fs) > 4 else None
         label = "" if nm is None else f" ({nm})"
-        mse = float(np.mean((ys - f) ** 2))
+        # the error variance of one predictor, n - 2 degrees of
+        #   freedom, as R's .plt.fit() computes it for every fit
+        sse = float(((ys - f) ** 2).sum())
+        mse = sse / (len(ys) - 2) if len(ys) > 2 else np.nan
         tss = float(((ys - ys.mean()) ** 2).sum())
         rsq = 1 - float(((ys - f) ** 2).sum()) / tss \
             if tss > 0 else np.nan
-        lines.append(
-            f'fit="{fit}"{label}:  MSE: {fmt(mse, digits_d + 1)}'
-            f"   R-squared: {fmt(rsq, 3)}")
+        entry = dict(group=nm, fit=fit, mse=mse, rsq=rsq)
+        if fit == "lm" and xs is not None and len(xs) > 1:
+            # the line and its fit as R's .plt.fit() reports them
+            b1, b0 = np.polyfit(np.asarray(xs, float),
+                                np.asarray(ys, float), 1)
+            entry.update(b0=float(b0), b1=float(b1))
+            head = ("  " if nm is None
+                    else f"{by_name}: {nm}  " if by_name
+                    else f"{nm}:  ")
+            lines += [f"{head}Line: b0 = {b0:.3f}    b1 = {b1:.3f}",
+                      f"  Linear Model MSE = {mse:,.3f}   "
+                      f"Rsq = {rsq:.3f}"]
+        else:
+            lines.append(
+                f'fit="{fit}"{label}:  MSE: {fmt(mse, digits_d + 1)}'
+                f"   R-squared: {fmt(rsq, 3)}")
+        fits.append(entry)
+    # one relationship reads as its own entries; groups by name
+    if list(cors) == [None]:
+        record_stats(**cors[None])
+    else:
+        record_stats(cor=cors)
+    if fits:
+        record_stats(fit=fits if len(fits) > 1 else fits[0])
     return lines
 
 
+def _cor_values(xg, yg):
+    """The correlation of _cor_block as numbers."""
+    n = len(xg)
+    if n < 4:
+        return dict(n=n)
+    r = float(np.corrcoef(xg, yg)[0, 1])
+    tval = r * np.sqrt((n - 2) / max(1 - r * r, 1e-12))
+    p = 2 * sps.t.sf(abs(tval), n - 2)
+    zlo = np.arctanh(r) - 1.959964 / np.sqrt(n - 3)
+    zhi = np.arctanh(r) + 1.959964 / np.sqrt(n - 3)
+    return dict(n=n, r=r, t=float(tval), df=n - 2, p_value=float(p),
+                ci_lb=float(np.tanh(zlo)), ci_ub=float(np.tanh(zhi)))
+
+
 def md_outliers(xv, yv, ids, MD_cut, out_cut):
     """Bivariate outliers by Mahalanobis distance from the
     centroid: MD_cut an absolute threshold, out_cut a proportion
@@ -144,7 +191,7 @@ def md_outliers(xv, yv, ids, MD_cut, out_cut):
     n_lines = min(len(out_idx) + 3, len(dst))
     w_id = max(len(s) for s in ids)
     w_md = max(len(fmt(d, 2)) for d in dst)
-    lines = [">>> Outlier analysis with Mahalanobis Distance",
+    lines = [">>> Outlier analysis with squared Mahalanobis Distance",
              "",
              f"{'MD':>{w_md}} {'ID':>{w_id + 1}}",
              f"{'-----':>{w_md}} {'-----':>{w_id + 1}}"]
@@ -155,7 +202,7 @@ def md_outliers(xv, yv, ids, MD_cut, out_cut):
         lines.append(f"{fmt(dst[j], 2):>{w_md}} "
                      f"{ids[j]:>{w_id + 1}}")
     if n_lines < len(dst):
-        lines.append(f"{'...':>{w_md}} {'...':>{w_id + 1}}")
+        lines.append(f"{'...':>{w_md - 1}} {'...':>{w_id + 2}}")
     return out_idx, lines
 
 
@@ -542,3 +589,202 @@ def nested_stats(cols, names, y_ser, stat, y_name, digits_d=2):
         title = (f"{STAT_LBL.get(stat, stat)} of {y_name} by "
                  + ", ".join(names))
     return [title, "-" * len(title), ""] + body.split("\n") + [""]
+
+
+# ----- the statistics returned with a Chart() figure ----------------
+
+class ChartStats:
+    """The statistics behind a Chart(), attached to the returned figure
+    as fig.stats. Each entry reads as an attribute, fig.stats.freq, or
+    by name, fig.stats["freq"], named as R's Chart() names its returned
+    list where it has a counterpart: freq, prop, values, p_value,
+    n_miss. text holds the console report, kept when quiet=True
+    suppresses its display. Not a dict subclass, so that an entry such
+    as values is not shadowed by a dict method. R analog: the list
+    that Chart() returns invisibly"""
+
+    def __init__(self, *args, **kw):
+        for k, v in dict(*args, **kw).items():
+            setattr(self, k, v)
+
+    def __getitem__(self, name):
+        try:
+            return self.__dict__[name]
+        except KeyError:
+            raise KeyError(name) from None
+
+    def __setitem__(self, name, value):
+        self.__dict__[name] = value
+
+    def __contains__(self, name):
+        return name in self.__dict__
+
+    def __iter__(self):
+        return iter(self.__dict__)
+
+    def __len__(self):
+        return len(self.__dict__)
+
+    def keys(self):
+        return self.__dict__.keys()
+
+    def get(self, name, default=None):
+        return self.__dict__.get(name, default)
+
+    def update(self, *args, **kw):
+        for k, v in dict(*args, **kw).items():
+            self.__dict__[k] = v
+
+    def __repr__(self):
+        keys = ", ".join(k for k in self.__dict__ if k != "text")
+        return (self.get("text", "").rstrip() + "\n\n"
+                f"[ChartStats: {keys}]")
+
+    __str__ = __repr__
+
+
+def _ordered_counts(s):
+    t = s.groupby(s, observed=True).size()
+    return t[t > 0]
+
+
+def _chisq_1d(cnt):
+    if len(cnt) < 2:
+        return {}
+    chi, p = sps.chisquare(cnt.to_numpy())
+    return dict(chisq=float(chi), df=len(cnt) - 1, p_value=float(p))
+
+
+def _xtab_stats(ct):
+    obs = ct.to_numpy()
+    out = dict(freq=ct, prop=ct / obs.sum(),
+               prop_col=ct / ct.sum(axis=0),
+               prop_row=ct.div(ct.sum(axis=1), axis=0))
+    chi, p, dof, _ = sps.chi2_contingency(obs, correction=False)
+    if np.isfinite(chi):
+        out.update(chisq=float(chi), df=int(dof), p_value=float(p),
+                   cramer_v=float(np.sqrt(chi / ((min(obs.shape) - 1)
+                                                 * obs.sum()))))
+    return out
+
+
+def chart_stats_data(x_ser, by_ser, y_ser, stat, facet_ser=None,
+                     n_miss=None):
+    """The numbers of the Chart() report as pandas objects: counts
+    with proportions and the chi-square test of equal probabilities;
+    a cross-tabulation with cell, column, and row proportions,
+    Cramer's V, and the test of independence; or the summary of y
+    over the levels of x and the plotted values, or the table of the
+    statistic over the grouping"""
+    st = ChartStats()
+    if y_ser is None:
+        grp = by_ser if by_ser is not None else facet_ser
+        if grp is None:
+            cnt = _ordered_counts(x_ser)
+            st.update(n_dim=1, freq=cnt, prop=cnt / cnt.sum(),
+                      n_miss=n_miss, **_chisq_1d(cnt))
+        elif by_ser is not None and facet_ser is not None:
+            # one cross-tabulation per panel
+            panels = {}
+            for lv in _category_order_sorted(facet_ser):
+                m = facet_ser == lv
+                panels[lv] = ChartStats(
+                    _xtab_stats(pd.crosstab(by_ser[m], x_ser[m])))
+            st.update(n_dim=3, panels=panels)
+        else:
+            st.update(n_dim=2, **_xtab_stats(pd.crosstab(grp, x_ser)))
+        return st
+
+    fun = STAT_FUN[stat]
+    if by_ser is None and facet_ser is None:
+        y = pd.to_numeric(y_ser)
+        g = y.groupby(x_ser, observed=True, sort=True)
+        summary = pd.DataFrame({
+            "n": g.count(), "miss": g.size() - g.count(),
+            "mean": g.mean(), "sd": g.std(ddof=1), "min": g.min(),
+            "mdn": g.median(), "max": g.max()})
+        st.update(n_dim=1, summary=summary, values=fun(g))
+        return st
+    grp = by_ser if by_ser is not None else facet_ser
+    df = pd.DataFrame({"g": grp, "x": x_ser, "y": pd.to_numeric(y_ser)})
+    tbl = (df.groupby(["g", "x"], observed=True)["y"].agg(fun)
+           .unstack("x"))
+    st.update(n_dim=2, summary=tbl)
+    return st
+
+
+
+# ----- statistics of the current call, returned with its figure -----
+
+import contextvars as _contextvars
+
+CALL_STATS = _contextvars.ContextVar("lessPy_call_stats", default=None)
+
+# the caller's output while a report is captured, for advisories
+_REAL_OUT = _contextvars.ContextVar("lessPy_real_stdout", default=None)
+
+
+def advise(msg):
+    """An advisory, shown whether or not the report is quiet, as R's
+    message() is: written past a captured report to the caller's
+    output."""
+    out = _REAL_OUT.get()
+    if out is None:
+        print(msg)
+    else:
+        print(msg, file=out)
+
+
+def record_stats(**kw):
+    """Add entries to the statistics of the current Chart(), X(), or
+    XY() call; a no-op outside one."""
+    st = CALL_STATS.get()
+    if st is not None:
+        st.update(kw)
+
+
+def attach_stats(func, capture=False):
+    """Return the figure with the call's statistics as fig.stats. A
+    plotly Figure accepts no new attributes by assignment, so it is
+    set past plotly's validation; it survives update_layout() and
+    stays out of the figure's JSON, though go.Figure(fig) copies the
+    figure without it.
+
+    capture: the function prints its report from many places, so run
+    it with quiet=False and its output captured as stats.text, then
+    display that text unless the caller asked for quiet."""
+    import functools
+    import io
+    import sys
+    from contextlib import redirect_stdout
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        token = CALL_STATS.set(ChartStats() if capture else None)
+        try:
+            if capture:
+                quiet = resolve_quiet(kwargs.get("quiet"))
+                kwargs["quiet"] = False
+                buf = io.StringIO()
+                real = _REAL_OUT.set(sys.stdout)
+                try:
+                    with redirect_stdout(buf):
+                        fig = func(*args, **kwargs)
+                finally:
+                    _REAL_OUT.reset(real)
+                    out = buf.getvalue()
+                    if not quiet:
+                        sys.stdout.write(out)
+                st = CALL_STATS.get()
+                st["text"] = out.rstrip("\n")
+            else:
+                fig = func(*args, **kwargs)
+                st = CALL_STATS.get()
+        finally:
+            CALL_STATS.reset(token)
+        if fig is not None and hasattr(fig, "layout"):
+            object.__setattr__(fig, "stats",
+                               st if st is not None else ChartStats())
+        return fig
+
+    return wrapper

lessPy/style.py

@@ -0,0 +1,160 @@
+# style.py — analog of lessR's style(): the color theme, a sub_theme,
+# and the individual appearance settings that every visualization
+# reads, Chart(), X(), and XY() alike, until changed.
+#
+# The settings of each theme come from lessR itself (_themes.py,
+# generated from style(theme[, sub_theme])), so a theme draws the same
+# colors in both packages. Text sizes are lessPy's own, tuned for
+# plotly in notebooks, and naming a theme leaves them as they were.
+# R analog: style.R
+
+import copy
+
+from . import utils
+from ._themes import THEMES
+
+# the text sizes, which a theme does not set
+_SIZE_KEYS = ("main_size", "lab_size", "lab_x_size", "lab_y_size",
+              "axis_size", "axis_x_size", "axis_y_size", "sub_size",
+              "add_size")
+
+# lessR style() parameters with no lessPy counterpart: R Markdown output
+#   and console settings, and parameters that lessPy takes in the call
+#   of the visualization function instead
+_R_ONLY = ("results", "explain", "interpret", "document", "code",
+           "width", "show", "lessR.use_plotly", "notes",
+           "brief", "offset", "rotate_x", "rotate_y", "labels",
+           "labels_size", "labels_digits", "labels_position")
+
+# start-up settings that a theme does not reach: lessPy's own options,
+#   captured once at import, before any style() call
+_BASELINE = copy.deepcopy(utils._OPTIONS)
+
+
+def _style_keys():
+    keys = set(THEMES["colors"]["none"]) | set(_SIZE_KEYS)
+    keys |= {"quiet", "suggest", "digits_d", "n_cat", "grid_col",
+             "legend_border"}
+    return keys
+
+
+def _theme_settings(theme, sub_theme):
+    if theme not in THEMES:
+        raise ValueError(
+            f"theme='{theme}' is not a theme. Themes: "
+            + ", ".join(THEMES))
+    variant = "none" if sub_theme is None else sub_theme
+    if variant not in THEMES[theme]:
+        raise ValueError(
+            f"sub_theme='{sub_theme}' is not a sub_theme. Sub-themes: "
+            "default, black, wsj")
+    return THEMES[theme][variant]
+
+
+def style(theme=None, sub_theme=None, set=None, get=False, reset=True,
+          **settings):
+    """Set the appearance of every subsequent visualization.
+
+    style("darkred") applies a color theme, resetting every other
+    setting to the theme's own; sub_theme="black" draws on a black
+    background, "default" on a gray panel with white grid lines, as in
+    lessR. Name any setting to change only that one, as in
+    style(panel_fill="gray95", axis_size=1.1), with or without a theme.
+    style() alone restores the default theme. get=True returns the
+    current settings as a dict, which set= restores. A visualization
+    function's own theme= applies a theme for that call only.
+
+    trans sets the transparency of both the bar and the point fills.
+    Settings that lessR's style() takes for R Markdown or the console,
+    or that lessPy takes in the visualization call (rotate_x, labels,
+    ...), are not available here. R analog: style()"""
+    keys = _style_keys()
+
+    if set is not None:
+        for k, v in set.items():
+            utils._OPTIONS[k] = copy.deepcopy(v)
+        return None
+
+    # transparency names both fills at once, as in lessR
+    for alias in ("trans", "transparency"):
+        if alias in settings:
+            t = settings.pop(alias)
+            settings.setdefault("trans_bar_fill", t)
+            settings.setdefault("trans_pt_fill", t)
+
+    bad = [k for k in settings if k not in keys]
+    if bad:
+        r_only = [k for k in bad if k in _R_ONLY]
+        other = [k for k in bad if k not in _R_ONLY]
+        msg = []
+        if r_only:
+            msg.append(
+                f"{', '.join(r_only)}: lessR style() settings with no "
+                "lessPy counterpart (R Markdown and console output, or "
+                "set in the call of the visualization function)")
+        if other:
+            msg.append(f"{', '.join(other)}: not a style() setting")
+        raise ValueError(".\n".join(msg))
+
+    nothing = (theme is None and sub_theme is None and not settings
+               and not get)
+    if nothing:
+        theme = "colors"                 # style() restores the default
+
+    if (theme is not None or sub_theme is not None) and reset:
+        th = theme if theme is not None else utils.get_option(
+            "theme", "colors")
+        st = (sub_theme if sub_theme is not None
+              else None if theme is not None
+              else utils.get_option("sub_theme"))
+        base = copy.deepcopy(_BASELINE)
+        base.update(copy.deepcopy(_theme_settings(th, st)))
+        utils._OPTIONS.clear()
+        utils._OPTIONS.update(base)
+        utils._OPTIONS["theme"] = th
+        utils._OPTIONS["sub_theme"] = st
+
+    for k, v in settings.items():
+        utils._OPTIONS[k] = v
+
+    if get:
+        return {k: copy.deepcopy(utils._OPTIONS.get(k))
+                for k in sorted(keys | {"theme", "sub_theme"})}
+    return None
+
+
+class _AppliedTheme:
+    """A theme for the duration of one call, the settings restored
+    after it. R analog: the theme= of Chart(), X(), and XY(), which
+    call style(theme) with on.exit(style(old_theme))"""
+
+    def __init__(self, theme):
+        self.theme = theme
+
+    def __enter__(self):
+        self.saved = copy.deepcopy(utils._OPTIONS)
+        if self.theme is not None and \
+                self.theme != utils.get_option("theme"):
+            style(self.theme)
+        return self
+
+    def __exit__(self, *exc):
+        utils._OPTIONS.clear()
+        utils._OPTIONS.update(self.saved)
+        return False
+
+
+def with_theme(func, own_param=False):
+    """Give a visualization function the theme= of its lessR analog:
+    the theme applies to that call only. own_param: the function takes
+    theme itself (Chart), so it is passed on as well."""
+    import functools
+
+    @functools.wraps(func)
+    def wrapper(*args, theme=None, **kwargs):
+        if own_param:
+            kwargs["theme"] = theme
+        with _AppliedTheme(theme):
+            return func(*args, **kwargs)
+
+    return wrapper

lessPy/sunflower_plotly.py

@@ -0,0 +1,140 @@
+# sunflower_plotly.py — XY(form="sunflower")
+#
+# A DESIGN, not a translation: lessR draws the sunflower only with
+# base R's sunflowerplot() and, faceted, a lattice panel of its own
+# (.plt.sunflower.facet), so there is no plotly source to port. As
+# there: one dot at each distinct (x, y), and where k > 1
+# observations coincide, k petals radiating from it, the first
+# vertical, evenly spaced (sunflowerplot()'s angles), 1/8 inch long.
+# Dots take bar_fill_cont, petals the point color, as .plt.main().
+# Plotly has no petal symbol, so the petals are line segments in data
+# units, sized from the plotting region of the default figure so that
+# they read as equal-length spokes. facet= draws one panel per level,
+# each with its own coordinates and so its own petal counts.
+
+import numpy as np
+import plotly.graph_objects as go
+
+from .plotly_utils import (
+    axis_format, axis_num, facet_fig, facet_panels, finish_facet,
+    make_trans, plot_border, plotly_style, to_hex, x_grid,
+)
+from .utils import get_option, pretty
+
+_PETAL_PX = 12          # 1/8 inch at 96 dpi
+_PLOT_PX = (540, 330)   # plotting region of the default figure
+
+
+def _counts(x, y):
+    """Distinct coordinates and how many observations share each.
+    R analog: table(x, y) of .plt.main()"""
+    ok = np.isfinite(x) & np.isfinite(y)
+    pts, cnt = np.unique(np.column_stack((x[ok], y[ok])), axis=0,
+                         return_counts=True)
+    return pts[:, 0], pts[:, 1], cnt
+
+
+def _petals(xx, yy, cnt, dx, dy):
+    """Segments for every coordinate with more than one observation:
+    cnt petals, the first vertical. R analog: sunflowerplot()"""
+    sx, sy = [], []
+    for x0, y0, k in zip(xx, yy, cnt):
+        if k < 2:
+            continue
+        ang = np.pi / 2 + 2 * np.pi * np.arange(k) / k
+        for a in ang:
+            sx += [x0, x0 + dx * np.cos(a), None]
+            sy += [y0, y0 + dy * np.sin(a), None]
+    return sx, sy
+
+
+def _panel_traces(x, y, xr, yr, w_px, h_px, fill, color, pt_size,
+                  hover):
+    xx, yy, cnt = _counts(x, y)
+    dx = _PETAL_PX * (xr[1] - xr[0]) / w_px
+    dy = _PETAL_PX * (yr[1] - yr[0]) / h_px
+    sx, sy = _petals(xx, yy, cnt, dx, dy)
+    px = max(3.0, 5.5 * float(pt_size))
+    return [
+        go.Scatter(x=sx, y=sy, mode="lines",
+                   line=dict(color=to_hex(color), width=1),
+                   hoverinfo="skip", showlegend=False),
+        go.Scatter(x=xx, y=yy, mode="markers",
+                   marker=dict(size=px, color=to_hex(fill),
+                               line=dict(width=0)),
+                   customdata=cnt, hovertemplate=hover,
+                   showlegend=False)]
+
+
+def _range(v):
+    t = pretty(float(np.nanmin(v)), float(np.nanmax(v)))
+    pad = 0.04 * (t[-1] - t[0])
+    return t, (t[0] - pad, t[-1] + pad)
+
+
+def sunflower_plotly(x, y, x_lab, y_lab, main=None, facet=None,
+                     facet_order=None, facet_name=None, facet2=None,
+                     facet2_order=None, facet2_name=None, n_col=1,
+                     pt_size=1, fill=None, color=None, overlay=None,
+                     digits_d=2, axis_fmt="K", axis_x_pre="",
+                     axis_y_pre=""):
+    """The sunflower plot of x and y, single panel or faceted.
+    overlay(fig, x, y, row, col) adds a fit line or an ellipse to a
+    panel. Returns a plotly Figure."""
+    x = np.asarray(x, dtype=float)
+    y = np.asarray(y, dtype=float)
+    fill = get_option("bar_fill_cont", "#96AAC3") if fill is None \
+        else fill
+    color = get_option("pt_color", "#324E5C") if color is None \
+        else color
+    style_opts = plotly_style()
+    axT1, xr = _range(x)
+    axT2, yr = _range(y)
+    hover = (f"{x_lab}: %{{x}}<br>{y_lab}: %{{y}}<br>"
+             "count: %{customdata}<extra></extra>")
+
+    if facet is None:
+        fig = go.Figure(_panel_traces(x, y, xr, yr, *_PLOT_PX, fill,
+                                      color, pt_size, hover))
+        if overlay is not None:
+            overlay(fig, x, y, None, None)
+        ax_x = axis_num(x_lab, axT1, axis_format(axT1, digits_d,
+                                                 axis_fmt, axis_x_pre))
+        ax_y = axis_num(y_lab, axT2, axis_format(axT2, digits_d,
+                                                 axis_fmt, axis_y_pre))
+        ax_x.update(range=list(xr))
+        ax_y.update(range=list(yr), showgrid=True,
+                    gridcolor=to_hex(style_opts["grid_col"]),
+                    gridwidth=1, griddash="dot")
+        fig.update_layout(
+            xaxis=ax_x, yaxis=ax_y, template=None,
+            shapes=x_grid(axT1) + plot_border(),
+            plot_bgcolor=to_hex(style_opts["panel_fill"]),
+            paper_bgcolor=to_hex(style_opts["window_fill"]))
+    else:
+        labels, pos, sel, n_row_g, n_col = facet_panels(
+            facet, facet_order, facet2, facet2_order, facet_name,
+            facet2_name, n_col)
+        fig = facet_fig(n_row_g, n_col)
+        w_px = _PLOT_PX[0] / n_col
+        h_px = _PLOT_PX[1] * 1.3 / n_row_g
+        for i, m in enumerate(sel):
+            row, col = pos[i]
+            for tr in _panel_traces(x[m], y[m], xr, yr, w_px, h_px,
+                                    fill, color, pt_size, hover):
+                fig.add_trace(tr, row=row, col=col)
+            if overlay is not None and m.sum() > 2:
+                overlay(fig, x[m], y[m], row, col)
+        ax = {"axT1": axT1,
+              "axL1": axis_format(axT1, digits_d, axis_fmt, axis_x_pre),
+              "axT2": axT2,
+              "axL2": axis_format(axT2, digits_d, axis_fmt, axis_y_pre)}
+        finish_facet(fig, labels, ax, x_lab, y_lab, gridT1=axT1,
+                     style_opts=style_opts, n_col=n_col, pos=pos)
+        fig.update_xaxes(range=list(xr))
+        fig.update_yaxes(range=list(yr))
+    if main:
+        fig.update_layout(title=dict(
+            text=main, x=0.5, xanchor="center",
+            font=dict(size=round(16 * get_option("main_size", 1)))))
+    return fig

lessPy/ttest.py

@@ -24,7 +24,7 @@ import numpy as np
 import pandas as pd
 
 from .Regression import _getdigits
-from .utils import fmt, get_column, get_option
+from .utils import fmt, get_column, get_option, show_plots
 
 
 class ttestResults:
@@ -309,14 +309,14 @@ def _two_group(n1, m1, s1, n2, m2, s2, Ynm, Xnm, X1nm, X2nm,
     if graph and from_data:
         plots["two_group"] = _two_group_plot(
             YA, YB, Ynm, X1nm, X2nm, m1, m2, d)
-    return ttestResults(
+    return show_plots(ttestResults(
         kind="two-group", n_total=n1 + n2, digits_d=d,
         group1={"name": X1nm, "n": n1, "mean": m1, "sd": s1},
         group2={"name": X2nm, "n": n2, "mean": m2, "sd": s2},
         mean_diff=m1 - m2, pooled_sd=sw, cohen_d=smd,
         equal_var={"t": tvalue, "df": df, "p_value": pvalue,
                    "se": sterr, "lb": lb, "ub": ub},
-        welch=welch, plots=plots)
+        welch=welch, plots=plots))
 
 
 def _assumptions(YA, YB, X1nm, X2nm, Ynm, n1, n2, v1, v2, df1,
@@ -529,12 +529,12 @@ def _one_group(Y, n, m, s, mu, Ynm, brief, conf_level,
     if graph and from_data:
         plots["one_group"] = _one_group_plot(
             Y, Ynm, m, lb, ub, d, paired)
-    return ttestResults(
+    return show_plots(ttestResults(
         kind="paired" if paired else "one-group", n_total=n,
         digits_d=d, n=n, mean=m, sd=s, mu=mu,
         infer={"t": tvalue, "df": df, "p_value": pvalue,
                "se": sterr, "lb": lb, "ub": ub},
-        cohen_d=cohen, plots=plots)
+        cohen_d=cohen, plots=plots))
 
 
 def _needed_1(Edesired, conf_level, s, E, n, d):