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

lessPy/Correlation.py

@@ -27,7 +27,8 @@ class CorrelationResults:
                 f"r={self.r}, p={self.pvalue}>")
 
 
-def Correlation(x=None, y=None, data=None, miss="pairwise",
+def Correlation(x=None, y=None, data=None, filter=None,
+                miss="pairwise",
                 show="cor", method="pearson", brief=False,
                 digits_d=None, heat_map=True, main=None):
     """Correlation of two variables (with a significance test) or
@@ -42,6 +43,16 @@ def Correlation(x=None, y=None, data=None, miss="pairwise",
     if method not in ("pearson", "spearman", "kendall"):
         raise ValueError('method: "pearson", "spearman", '
                          '"kendall"')
+    # subset rows, as in ttest(), ANOVA() and Regression(). Correlation()
+    #   reaches its data by two routes, so filter whichever one carries
+    #   it, always before a variable list subsets the columns
+    if filter is not None:
+        if data is not None:
+            data = data.query(filter)
+        elif isinstance(x, pd.DataFrame):
+            x = x.query(filter)
+        else:
+            raise ValueError("filter needs data= or a DataFrame x")
     if y is not None:
         xv = _resolve1(x, data, "x")
         yv = _resolve1(y, data, "y")

lessPy/Flows.py

@@ -109,7 +109,11 @@ def Flows(value, stage1, stage2, stage3=None, data=None,
                    y=min(0.98, y_dom[1] + 0.03),
                    xanchor="center", yanchor="top",
                    font=dict(size=round(18 * labels_size))),
-        margin=dict(t=90, r=30, b=30, l=30),
+        # the top margin only needs to clear the title, which is
+        #   positioned in container coordinates; a fixed 90 left a
+        #   large gap below it
+        margin=dict(t=max(30, round(18 * labels_size * 2.2)),
+                    r=30, b=30, l=30),
         font=dict(size=round(15 * labels_size)),
         template=None,
         paper_bgcolor=to_hex(get_option("window_fill", "white")))

lessPy/X.py

@@ -35,7 +35,7 @@
 # violin bandwidth search (now the default bandwidth, as R),
 # out_cut/ID/ID_size outlier labels above the strip.
 # n_row/n_col lay the histogram/density/freq_poly facets out
-# as a grid (lattice bottom-up fill); not for the VBS bands.
+# as a grid (reading-order fill, top-left first); not for the VBS bands.
 # Not ported: aspect= (panel aspect is figure sizing in
 # plotly), the axis-format/margin family, add= annotations,
 # themes.

lessPy/XY.py

@@ -42,9 +42,10 @@
 # shared scatter_matrix helper (plt_mat_plotly). The faceted
 # scatter prints a summary table per grouping variable
 # (facet_summary ~ .vbs_summary_table).
-# The categorical-x delegations are not ported (bubble and
-# Cleveland displays are internal-only; categorical data
-# belong to Chart()). R's form="hexbin" is dropped by design:
+# A categorical x or y is refused with the call of the view it
+# belongs to, as XY.R's master control funnel now does (Aug
+# 2026); the dot plots XY() once drew for row_names and for a
+# categorical variable with stat= are Chart(form="dot")'s. R's form="hexbin" is dropped by design:
 # plotly has no hexbin trace.
 
 import math
@@ -262,7 +263,7 @@ def _xy_facet(xv, yv, by_arr, by_order, facet_arr, facet_order,
               facet2_name=None, n_col=1):
     """One scatter panel per facet level on shared axes,
     following the faceted-histogram conventions (_hs_facet):
-    first level on the bottom panel, strip labels, legend
+    first level on the top panel, strip labels, legend
     entries from the first panel only. facet2: the two-facet
     grid, rows = facet2 levels."""
     labels, pos, sel, n_row_g, n_col = facet_panels(
@@ -738,7 +739,7 @@ def _ts_facet(xv, yv, facet_arr, facet_order, fill0, border0,
               facet2_order=None, facet2_name=None, n_col=1):
     """One time-series panel per facet level on shared axes,
     following the faceted-scatter conventions (_xy_facet):
-    first level on the bottom panel, strip labels. The x axis
+    first level on the top panel, strip labels. The x axis
     uses plotly's native date ticks, as the single-panel time
     series does. R analog: the lattice cont_cont path for a
     date x. facet2: the two-facet grid, rows = facet2 levels."""
@@ -790,7 +791,7 @@ def _ts_facet(xv, yv, facet_arr, facet_order, fill0, border0,
                     if "markers" in mode_pts else None),
             line=dict(color=to_hex(border0), width=1.5),
             hovertemplate=hover, showlegend=False,
-        ), row=row, col=col)           # first level bottom
+        ), row=row, col=col)           # first level top-left
 
     finish_facet(fig, labels, ax, x_lab, y_lab,
                  gridT1=None, style_opts=style_opts,
@@ -988,10 +989,11 @@ def XY(x, y=None, data=None, filter=None, by=None, facet=None,
        segments_x=None, segments_y=None,
        add=None, x1=None, y1=None, x2=None, y2=None,
        fill=None, color=None, transparency=None,
-       pt_size=1, pt_shape="circle", jitter_x=None, jitter_y=None,
+       pt_size=1, pt_shape="circle", line_width=1.5,
+       jitter_x=None, jitter_y=None,
        MD_cut=0, out_cut=0, out_shape="circle-open", out_size=1,
        ID=None, ID_color="gray50", ID_size=0.6,
-       fit="off", fit_power=1, fit_se=None, plot_errors=False,
+       fit="off", fit_power=1, fit_se=None, fit_errors=False,
        fit_new=None,
        fit_color=None, fit_lwd=None, span=0.75,
        ellipse=0, ellipse_fill=None, ellipse_color=None,
@@ -1007,7 +1009,8 @@ def XY(x, y=None, data=None, filter=None, by=None, facet=None,
        axis_fmt="K", axis_x_pre="", axis_y_pre="",
        rotate_x=0, rotate_y=0, scale_x=None, scale_y=None,
        xlab=None, ylab=None, main=None, digits_d=None,
-       quiet=None):
+       quiet=None,
+       plot_errors=None):
     """Analytic view of the relationship between two numerical
     variables, optionally grouped (by=). A date x displays as a
     time series. Variables are strings naming columns of the
@@ -1051,19 +1054,25 @@ def XY(x, y=None, data=None, filter=None, by=None, facet=None,
     if center_line not in ("off", "mean", "median", "zero"):
         raise ValueError(
             'center_line: "off", "mean", "median", or "zero"')
+    if plot_errors is not None:
+        raise ValueError(
+            "Parameter plot_errors has been renamed to fit_errors. "
+            "The segments it draws join each point to the fitted line, "
+            "so they are the errors of the fit, and the name now says "
+            "which fit they belong to, as fit, fit_color, and fit_se do.")
     if center_line != "off" and facet is not None:
         raise ValueError(
             "center_line draws on a single panel: no facet=")
-    if plot_errors:
+    if fit_errors:
         if fit == "off":
             raise ValueError(
-                "plot_errors draws residual segments to the fit "
+                "fit_errors draws residual segments to the fit "
                 "line: specify fit=")
         if form != "scatter":
-            raise ValueError('plot_errors applies to form="scatter"')
+            raise ValueError('fit_errors applies to form="scatter"')
         if facet is not None:
             raise ValueError(
-                "plot_errors draws on a single panel: no facet=")
+                "fit_errors draws on a single panel: no facet=")
     if (scale_x is not None or scale_y is not None) \
             and facet is not None:
         raise ValueError(
@@ -1152,39 +1161,43 @@ def XY(x, y=None, data=None, filter=None, by=None, facet=None,
             xlab, ylab, main, digits_d, quiet),
             rotate_x, rotate_y)
 
-    # ----- row_names: the data-frame row labels as a categorical
-    # axis -> a Cleveland dot plot, delegated to Chart(form="dot")
-    # (categorical variables live in Chart), the numeric variable
-    # its value ------------------------------------------------------
+    # ----- row_names: each row label identifies a single case, a
+    # categorical axis that belongs to Chart(form="dot")
+    # R analog: XY.R categorical refusal, x.unique branch
     _ROW_KW = ("row_names", "row.names")
     x_row = isinstance(x, str) and x in _ROW_KW
     y_row = isinstance(y, str) and y in _ROW_KW
     if x_row or y_row:
-        from .Chart import Chart
-        val = y if x_row else x
-        if (not isinstance(val, str) or val in _ROW_KW
-                or not pd.api.types.is_numeric_dtype(
-                    get_column(data, val, "x" if x_row else "y"))):
+        cont = y if x_row else x
+        raise TypeError(
+            "XY() requires a continuous x and a continuous y.\n"
+            "row_names is categorical.\n\n"
+            "Each level of row_names identifies a single case, so\n"
+            f"  display the values of {cont} directly with Chart():\n"
+            f"  Chart('row_names', y='{cont}', form='dot')")
+
+    # stat, sort, and the segments_x/_y droplines served the dot
+    # plot XY() once drew of a categorical variable, now Chart()'s;
+    # R's stat aggregates y within bins of x (n_bins), not ported
+    if stat is not None:
+        cat_, cont = "x", "y"
+        for a, b in ((x, y), (y, x)):
+            if (isinstance(a, str) and isinstance(b, str)
+                    and a in data.columns and b in data.columns
+                    and not pd.api.types.is_numeric_dtype(data[a])):
+                cat_, cont = a, b
+        raise ValueError(
+            "stat in XY() aggregates y within bins of x (n_bins), "
+            "which is not yet ported. For a statistic of a numerical "
+            "variable across the levels of a categorical one, use "
+            f"Chart():\n  Chart('{cat_}', y='{cont}', stat='{stat}')")
+    for nm, v in (("sort", None if sort == "0" else sort),
+                  ("segments_x", segments_x),
+                  ("segments_y", segments_y)):
+        if v is not None:
             raise ValueError(
-                "row_names pairs with one numerical variable")
-        names = data.index.astype(str)
-        d2 = data.copy()
-        d2["row_names"] = pd.Categorical(
-            names, categories=list(dict.fromkeys(names)))
-        # no by= here, so a single scatterplot fill (XY's pt_color
-        # default) rather than Chart's per-category dot hues
-        dot_fill = (get_option("pt_color", "#324E5C")
-                    if fill is None else fill)
-        # XY/lessR names droplines by the axis they reach (segments_y
-        # = to the y axis, i.e. horizontal); Chart names them by
-        # direction (segments_x = horizontal) -- so they swap
-        return Chart(
-            "row_names", y=val, data=d2, form="dot", horiz=y_row,
-            sort=sort, segments_x=segments_y, segments_y=segments_x,
-            fill=dot_fill, color=color, pt_size=pt_size, main=main,
-            xlab=xlab, ylab=ylab, digits_d=digits_d,
-            rotate_x=rotate_x, rotate_y=rotate_y,
-            axis_fmt=axis_fmt, quiet=quiet)
+                f"{nm} applies to the dot plot of a categorical "
+                "variable, which is Chart(form='dot'), not XY()")
 
     # ----- resolve variables and filter ---------------------------
     # ".Index" is the row-number pseudo-variable (1..n) for a run
@@ -1204,27 +1217,6 @@ def XY(x, y=None, data=None, filter=None, by=None, facet=None,
     if index_y:
         y = "Index"
 
-    # stat= aggregates a numerical variable by a categorical one and
-    # shows a Cleveland dot plot -- delegate to Chart(form="dot"),
-    # its tested renderer (categorical variables live in Chart)
-    if stat is not None:
-        from .Chart import Chart
-        x_num = pd.api.types.is_numeric_dtype(x_ser)
-        y_num = pd.api.types.is_numeric_dtype(y_ser)
-        common = dict(
-            data=data, by=by, facet=facet, form="dot", stat=stat,
-            sort=sort, fill=fill, color=color,
-            transparency=transparency, pt_size=pt_size, main=main,
-            digits_d=digits_d, rotate_x=rotate_x, rotate_y=rotate_y,
-            axis_fmt=axis_fmt, quiet=quiet)
-        if not x_num and y_num:            # categorical x, value y
-            return Chart(x, y=y, xlab=xlab, ylab=ylab, **common)
-        if x_num and not y_num:            # value x, categorical y
-            return Chart(y, y=x, horiz=True, xlab=xlab, ylab=ylab,
-                         **common)
-        raise ValueError(
-            "XY() with stat= needs one categorical and one "
-            "numerical variable (a Cleveland dot plot)")
     by_ser = get_column(data, by, "by") if by is not None else None
     (facet_ser, facet_name,
      facet2_ser, facet2_name) = resolve_facet(data, facet, "XY")
@@ -1268,33 +1260,40 @@ def XY(x, y=None, data=None, filter=None, by=None, facet=None,
             pass
 
     is_date = pd.api.types.is_datetime64_any_dtype(x_ser)
-    # a categorical/continuous mix with facet= is X()'s display:
-    # redirect, as XY.R's Trellis check does
-    if facet is not None and not is_date:
-        x_num = pd.api.types.is_numeric_dtype(x_ser)
-        y_num = pd.api.types.is_numeric_dtype(y_ser)
-        if x_num != y_num:
-            cont, cat_ = (x, y) if x_num else (y, x)
-            f_txt = ("[" + ", ".join(f"'{f}'" for f in facet)
-                     + "]"
-                     if isinstance(facet, (list, tuple))
-                     else f"'{facet}'" if isinstance(facet, str)
-                     else f"'{facet_name}'")
+    # XY() displays the relationship of two continuous variables; a
+    # categorical x or y belongs to another view, so name its call
+    # rather than render. R analog: XY.R master control funnel
+    x_cat = not is_date and not pd.api.types.is_numeric_dtype(x_ser)
+    y_cat = not pd.api.types.is_numeric_dtype(y_ser)
+    if x_cat or y_cat:
+        head = "XY() requires a continuous x and a continuous y.\n"
+        if x_cat and y_cat:
             raise TypeError(
-                "XY() requires a continuous x and a continuous "
-                "y.\nFor a faceted distribution of the "
-                f"continuous {cont} across the levels\nof the "
-                f"categorical {cat_}, use X() with a by "
-                f"variable:\n  X('{cont}', by='{cat_}', "
-                f"facet={f_txt})")
-    for nm, s in ((x, x_ser), (y, y_ser)):
-        if s is x_ser and is_date:
-            continue
-        if not pd.api.types.is_numeric_dtype(s):
+                head + f"Both {x} and {y} are categorical.\n\n"
+                "For two categorical variables, use Chart() with a "
+                f"by variable:\n  Chart('{x}', by='{y}', "
+                "form='bubble')")
+        cont, cat_, cat_s = ((y, x, x_ser) if x_cat
+                             else (x, y, y_ser))
+        if not cat_s.dropna().duplicated().any():
             raise TypeError(
-                f"XY() analyzes the relationship of two numerical "
-                f"variables, but '{nm}' is {s.dtype}. For a "
-                "categorical variable use Chart().")
+                head + f"{cat_} is categorical.\n\n"
+                f"Each level of {cat_} identifies a single case, so\n"
+                f"  display the values of {cont} directly with "
+                f"Chart():\n  Chart('{cat_}', y='{cont}', "
+                "form='dot')")
+        f_txt = ""
+        if facet is not None:
+            f_txt = (", facet=[" + ", ".join(f"'{f}'" for f in facet)
+                     + "]" if isinstance(facet, (list, tuple))
+                     else f", facet='{facet}'"
+                     if isinstance(facet, str)
+                     else f", facet='{facet_name}'")
+        raise TypeError(
+            head + f"{cat_} is categorical.\n\n"
+            f"For the distribution of the continuous {cont} across\n"
+            f"  the levels of the categorical {cat_}, use X() with "
+            f"a by variable:\n  X('{cont}', by='{cat_}'{f_txt})")
 
     # ts_NA= replaces missing y with a set value before the NA
     # rows are dropped, so a gap in the series becomes that value
@@ -1659,17 +1658,17 @@ def XY(x, y=None, data=None, filter=None, by=None, facet=None,
 
     # ----- fit lines and SE bands ---------------------------------
     # with by= the bands default off, as in R (XY.R line ~484);
-    # plot_errors shows residuals, not a band, so it too defaults
+    # fit_errors shows residuals, not a band, so it too defaults
     # the band off (XY.R line ~483)
     if fit_se is None:
-        fit_se = 0 if plot_errors else (0.95 if by is None else 0)
+        fit_se = 0 if fit_errors else (0.95 if by is None else 0)
     se_levels = [lv for lv in (fit_se if isinstance(
         fit_se, (list, tuple)) else [fit_se]) if lv]
     if form == "contour":              # R: no SE bands on contour
         se_levels = []
 
     fit_lines, se_polys, fit_stats = [], [], []
-    err_lines = []                     # plot_errors residual segments
+    err_lines = []                     # fit_errors residual segments
     if fit != "off":
         for nm, xg, yg in groups:
             if len(xg) < 2:
@@ -1678,7 +1677,7 @@ def XY(x, y=None, data=None, filter=None, by=None, facet=None,
                 xs, ys_s, f, se_f = _loess(xg, yg, span)
                 fit_lines.append({"name": nm, "x": xs, "y": f})
                 fit_stats.append((nm, fit, ys_s, f))
-                if plot_errors:
+                if fit_errors:
                     err_lines.append((xs, ys_s, f))
                 for lv in se_levels:
                     tq = sps.t.ppf((1 + lv) / 2, len(xs) - 1)
@@ -1692,7 +1691,7 @@ def XY(x, y=None, data=None, filter=None, by=None, facet=None,
             fit_lines.append({"name": nm, "x": xs[okf],
                               "y": f[okf]})
             fit_stats.append((nm, fit, ys_s[okf], f[okf]))
-            if plot_errors:
+            if fit_errors:
                 err_lines.append((xs[okf], ys_s[okf], f[okf]))
             if fit == "lm":
                 for lv in se_levels:
@@ -1845,7 +1844,8 @@ def XY(x, y=None, data=None, filter=None, by=None, facet=None,
         y_lab=y if ylab is None else ylab,
         ax=ax, gridT1=gridT1, gridT2=ax["axT2"],
         main=main, digits_d=digits_d,
-        connect=is_date or show_runs or index_x, is_date=is_date,
+        connect=is_date or show_runs or index_x, ln_width=line_width,
+        is_date=is_date,
         pt_opacity=1 - transparency,
         area_polys=area_polys,
         fit_lines=fit_lines, fit_color=fit_color, fit_lwd=fit_lwd,
@@ -1866,9 +1866,9 @@ def XY(x, y=None, data=None, filter=None, by=None, facet=None,
         # .Index run chart, or a runs chart keeps its wide aspect)
         fig.update_layout(**square_layout(main=bool(main)))
 
-    # plot_errors: residual segment from each point to its fitted
+    # fit_errors: residual segment from each point to its fitted
     # value, drawn over the points (R plt.main.R ~1403, rgb 130,40,35)
-    if plot_errors and err_lines:
+    if fit_errors and err_lines:
         ex, ey = [], []
         for xs_, yo_, ff_ in err_lines:
             for i in range(len(xs_)):

lessPy/bc_items_plotly.py

@@ -0,0 +1,195 @@
+# bc_items_plotly.py — the multi-item stacked chart, Chart(x=[...]),
+# for a set of items that share one response scale, such as Likert
+# items. R analog: the multi-x path of Chart.R, its frequency table
+# from .bc.main() (multi), drawn there with base graphics, and the
+# faceted form .bar.stackedLattice(); this is the plotly design.
+#
+# Each item is one horizontal bar, divided into the counts of its
+# responses in a divergent palette, so the bars compose the response
+# distributions of all the items on one scale. Unfaceted, the items
+# are ordered by their mean response, the largest at the top; each
+# segment carries its percent of the item, omitted below 4%. With
+# facet=, one panel per level, the items in the order given, first
+# at the top, on one count scale (drawn by bc_facet_plotly).
+
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+
+from .utils import get_option, pretty
+from .plotly_utils import (
+    as_plotly_color, auto_text_color, axis_cat, axis_format,
+    axis_num, legend_style, plot_border, plotly_style, to_hex,
+    x_grid,
+)
+
+# theme -> the two sequential palettes of the divergent fill
+# R analog: .get_fill(theme, diverge=TRUE)
+_DIVERGE = {
+    "gray": ("grays", "grays"), "white": ("grays", "grays"),
+    "darkred": ("turquoises", "reds"), "red": ("turquoises", "reds"),
+    "rose": ("turquoises", "reds"),
+    "slatered": ("turquoises", "reds"),
+    "darkgreen": ("violets", "greens"),
+    "green": ("violets", "greens"), "purple": ("violets", "greens"),
+}
+
+
+def items_fill(theme, n):
+    """The divergent palette of n response colors for a theme, the
+    low responses in the first hue. R analog: .color_range(
+    .get_fill(theme, diverge=TRUE), n)"""
+    from .getColors import getColors
+    p1, p2 = _DIVERGE.get(theme or "colors", ("browns", "blues"))
+    return [c[:7] for c in getColors(p1, p2, n=max(n, 2),
+                                     quiet=True)][:n]
+
+
+def _resp_str(v):
+    if isinstance(v, float) and v.is_integer():
+        return str(int(v))
+    return str(v)
+
+
+def items_table(cols, names):
+    """Responses x items table of counts over the union of the
+    response values, with the weighted mean response of each item.
+    Items that do not share one response set compose no single
+    chart: raise. R analog: .bc.main() multi tabulation and the
+    one_plot test of Chart.R"""
+    # one_plot: every item's responses fall within the largest set
+    sets = [set(c.dropna().unique()) for c in cols]
+    widest = max(sets, key=len)
+    if any(s - widest for s in sets):
+        raise ValueError(
+            "The x variables do not share one set of response "
+            "categories, so they do not compose a single multi-item "
+            "chart. Chart each variable separately.")
+    first = cols[0]
+    if isinstance(first.dtype, pd.CategoricalDtype):
+        resp = list(first.cat.categories)
+        for c in cols[1:]:
+            if isinstance(c.dtype, pd.CategoricalDtype):
+                resp += [v for v in c.cat.categories if v not in resp]
+    else:
+        vals = set()
+        for c in cols:
+            vals |= set(c.dropna().unique())
+        resp = sorted(vals)
+    frq = pd.DataFrame(
+        {nm: c.value_counts().reindex(resp, fill_value=0)
+         for nm, c in zip(names, cols)}, index=resp)
+    frq.index = [_resp_str(r) for r in resp]
+    numeric = all(isinstance(r, (int, float, np.integer, np.floating))
+                  for r in resp)
+    wt = (np.array(resp, dtype=float) if numeric
+          else np.arange(1, len(resp) + 1, dtype=float))
+    with np.errstate(invalid="ignore", divide="ignore"):
+        wm = pd.Series((frq.to_numpy(dtype=float) * wt[:, None]).sum(0)
+                       / frq.to_numpy(dtype=float).sum(0),
+                       index=names)
+    return frq, wm, numeric
+
+
+def items_stats_lines(frq, wm, title, numeric=True):
+    """'Frequencies of Responses by Variable': one row per item,
+    its counts and its mean. R analog: .prntbl(t(x), 0) with the
+    Mean column of .bc.main() multi"""
+    t = frq.T
+    rows = [str(r) for r in t.index]
+    max_c1 = max(len(r) for r in rows) + 2
+    widths = [max(4, max(len(str(c)),
+                         max(len(f"{v:.0f}") for v in t[c])) + 1)
+              for c in t.columns]
+    mx = max(len(f"{round(v, 2):.15g}") for v in wm if np.isfinite(v))
+    hdr = " " * max_c1 + "".join(str(c).rjust(w)
+                                 for c, w in zip(t.columns, widths))
+    lines = [title, "", hdr + "   " + "Mean".rjust(mx + 1)]
+    for r in t.index:
+        ln = ("  " + str(r)).rjust(max_c1) + "".join(
+            f"{v:.0f}".rjust(w) for v, w in zip(t.loc[r], widths))
+        lines.append(ln + "   " + f"{wm[r]:.3f}".rjust(mx + 1))
+    if not numeric:
+        lines += ["", "Computation of the mean based on coding "
+                  "response categories from 1 to "
+                  f"{len(frq.index)}"]
+    return lines + [""]
+
+
+def bc_items_plotly(frq, order, fill, labels="%", labels_size=None,
+                    labels_cut=0.04, stack100=False, x_lab="",
+                    y_lab="", legend_title="Responses", main=None,
+                    digits_d=0, axis_fmt="K", axis_x_pre="",
+                    rotate_x=0, rotate_y=0, style_opts=None):
+    """One horizontal bar per item, stacked by response. frq:
+    responses x items counts; order: the items bottom to top."""
+    if style_opts is None:
+        style_opts = plotly_style()
+    cnt = frq[order].to_numpy(dtype=float)
+    tot = cnt.sum(axis=0)
+    with np.errstate(invalid="ignore", divide="ignore"):
+        share = np.where(tot > 0, cnt / tot, 0.0)
+    mat = share if stack100 else cnt
+    if labels_size is None:
+        labels_size = 0.8 - 0.008 * len(order)
+    txt_size = round(16 * labels_size)
+    fills = [as_plotly_color(f) for f in fill]
+    txt_cols = auto_text_color(fills, bg=style_opts["panel_fill"])
+
+    fig = go.Figure()
+    for i, r in enumerate(frq.index):
+        if labels == "off":
+            txt = None
+        else:
+            txt = [("" if s < labels_cut else
+                    f"{100 * s:.0f}%" if labels == "%" else
+                    f"{s:.2f}" if labels == "prop" else
+                    f"{c:.0f}")
+                   for s, c in zip(share[i], cnt[i])]
+        fig.add_trace(go.Bar(
+            x=mat[i], y=list(order), orientation="h", name=str(r),
+            marker=dict(color=fills[i % len(fills)],
+                        line=dict(width=0)),
+            text=txt, textposition="inside",
+            insidetextanchor="middle", textangle=0,
+            textfont=dict(size=txt_size,
+                          color=txt_cols[i % len(txt_cols)]),
+            customdata=np.stack([cnt[i], share[i]], axis=-1),
+            hovertemplate=(f"%{{y}}<br>{legend_title}: {r}"
+                           "<br>Count: %{customdata[0]:.0f}"
+                           "<br>% of item: %{customdata[1]:.1%}"
+                           "<extra></extra>"),
+        ))
+
+    top = 1.0 if stack100 else float(np.nanmax(tot)) if tot.size else 1
+    axT = pretty(0.0, top)
+    if stack100:
+        d = 2
+    else:
+        d = digits_d
+    x_ax = axis_num(x_lab, axT, axis_format(axT, d, axis_fmt,
+                                            axis_x_pre))
+    x_ax.update(range=[0, axT[-1] * (1 if stack100 else 1.02)])
+    y_ax = axis_cat(y_lab)
+    y_ax.update(categoryorder="array", categoryarray=list(order))
+    if rotate_x:
+        x_ax["tickangle"] = -rotate_x
+    if rotate_y:
+        y_ax["tickangle"] = -rotate_y
+    leg = legend_style(legend_title, style_opts)
+    leg["traceorder"] = "normal"
+    fig.update_layout(
+        barmode="stack", bargap=0.2,
+        xaxis=x_ax, yaxis=y_ax,
+        shapes=x_grid(axT) + plot_border(),
+        legend=leg, template=None,
+        plot_bgcolor=to_hex(style_opts["panel_fill"]),
+        paper_bgcolor=to_hex(style_opts["window_fill"]),
+    )
+    if main:
+        title_size = round(16 * get_option("main_size", 1))
+        fig.update_layout(
+            title=dict(text=main, x=0.5, xanchor="center", y=0.98,
+                       yanchor="top", font=dict(size=title_size)),
+            margin=dict(t=round(title_size * 2.2)))
+    return fig