lessPython 0.1.0__py3-none-any.whl

lessPy/plt_mat_plotly.py

@@ -0,0 +1,201 @@
+# plt_mat_plotly.py — the scatterplot matrix (SPLOM).
+#
+# Shared by Regression() and XY(), mirroring the single R helper
+# .plt.mat (plt.mat.R). The layout matches R's pairs() panels:
+#   lower triangle  scatter of (col var, row var) with a fit line
+#                   and its 95% confidence band
+#   upper triangle  the correlation coefficient, as text
+#   diagonal        the variable name, on the se_fill background
+# Regression() calls it with fit="lm"; XY() passes its own fit=
+# (default "off", so no line). Points are dropped listwise across
+# all variables first (R's na.omit).
+
+import numpy as np
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from scipy import stats as sps
+
+from .plotly_utils import (
+    as_plotly_color, axis_format, make_trans, plotly_style,
+    to_hex)
+from .utils import fmt, get_option, pretty
+
+
+def _axis_ref(k, kind):
+    """Domain reference string for the k-th subplot axis, as used
+    by shapes and annotations: 'x domain', 'x2 domain', ..."""
+    n = "" if k == 1 else str(k)
+    return f"{kind}{n} domain"
+
+
+def scatter_matrix(df, fit="lm", digits_d=2, cor_coef=True,
+                   main=None, band=True):
+    """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."""
+    cols = list(df.columns)
+    n = len(cols)
+    if n < 2:
+        raise ValueError(
+            "a scatterplot matrix needs at least 2 variables")
+
+    data = df.dropna()                 # R na.omit: listwise
+    vals = {c: data[c].to_numpy(dtype=float) for c in cols}
+    rng = {c: pretty(float(v.min()), float(v.max()))
+           for c, v in vals.items()}
+
+    style = plotly_style()
+    panel_fill = get_option("panel_fill", "white")
+    window_fill = get_option("window_fill", "white")
+    bg = window_fill if panel_fill == "transparent" else panel_fill
+    diag_fill = get_option("se_fill", "#1A1A1A19")
+    se_fill = get_option("se_fill", "#1A1A1A19")
+    border = to_hex(style["panel_border"])
+    pt_fill = get_option("pt_fill", get_option("pt_color",
+                                               "#324E5C"))
+    pt_color = get_option("pt_color", "#324E5C")
+    lab_color = to_hex(style["lab_color"])
+    fit_color = to_hex(get_option("fit_color", "#5C4032"))
+    fit_lwd = get_option("fit_lwd", 2)
+
+    # sizes shrink with the variable count, as R's cex.adj
+    px = 0.5 * max(2.5, 7.25 * (0.80 - 0.048 * n) / 0.75)
+    txt_size = max(9, round(10 * (1.6 - 0.065 * n)))
+
+    fig = make_subplots(rows=n, cols=n, horizontal_spacing=0.008,
+                        vertical_spacing=0.008)
+
+    do_fit = fit in ("lm", "loess")
+
+    for r in range(1, n + 1):          # r: row (top = 1)
+        for c in range(1, n + 1):      # c: column (left = 1)
+            k = (r - 1) * n + c        # subplot / axis index
+            xr, yr = _axis_ref(k, "x"), _axis_ref(k, "y")
+
+            # 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):
+                _cell_bg(fig, xr, yr, bg, border)
+                _scatter_cell(fig, r, c, vals[cols[c - 1]],
+                              vals[cols[r - 1]], fit, do_fit, px,
+                              pt_fill, pt_color, fit_color,
+                              fit_lwd, se_fill, band)
+                continue
+
+            # text cells (diagonal, upper correlation): an
+            # invisible point anchors the axes so the domain
+            # shape/text render
+            _anchor(fig, r, c)
+            if r == c:                 # diagonal: variable name
+                _cell_bg(fig, xr, yr, diag_fill, border)
+                fig.add_annotation(
+                    xref=xr, yref=yr, x=0.5, y=0.5, text=cols[r - 1],
+                    showarrow=False,
+                    font=dict(size=txt_size, color=lab_color))
+            else:                      # upper: correlation
+                _cell_bg(fig, xr, yr, bg, border)
+                a, b = vals[cols[r - 1]], vals[cols[c - 1]]
+                rr = float(np.corrcoef(a, b)[0, 1])
+                fig.add_annotation(
+                    xref=xr, yref=yr, x=0.5, y=0.5,
+                    text=fmt(rr, 2), showarrow=False,
+                    font=dict(size=txt_size, color="black"))
+
+    # per-column x range (col var) and per-row y range (row var)
+    for c in range(1, n + 1):
+        rc = rng[cols[c - 1]]
+        fig.update_xaxes(range=[rc[0], rc[-1]], showgrid=False,
+                         zeroline=False, showticklabels=False,
+                         ticks="", col=c)
+    for r in range(1, n + 1):
+        rr = rng[cols[r - 1]]
+        fig.update_yaxes(range=[rr[0], rr[-1]], showgrid=False,
+                         zeroline=False, showticklabels=False,
+                         ticks="", row=r)
+
+    # outer scales only: x on the bottom row, y on the left
+    # column, interior ticks (drop the endpoints, which would
+    # collide at the panel seams)
+    for c in range(1, n + 1):
+        t = rng[cols[c - 1]][1:-1]
+        fig.update_xaxes(
+            showticklabels=True, tickvals=t,
+            ticktext=axis_format(t, digits_d),
+            tickfont=dict(size=8), row=n, col=c)
+    for r in range(1, n + 1):
+        t = rng[cols[r - 1]][1:-1]
+        fig.update_yaxes(
+            showticklabels=True, tickvals=t,
+            ticktext=axis_format(t, digits_d),
+            tickfont=dict(size=8), row=r, col=1)
+
+    fig.update_layout(
+        template=None, showlegend=False,
+        plot_bgcolor=to_hex(bg),
+        paper_bgcolor=to_hex(window_fill))
+    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
+
+
+def _anchor(fig, r, c):
+    """A single invisible point, so a text-only cell's axes exist
+    and its domain-referenced shape and label are drawn."""
+    fig.add_trace(go.Scatter(
+        x=[0.5], y=[0.5], mode="markers",
+        marker=dict(opacity=0), hoverinfo="skip",
+        showlegend=False), row=r, col=c)
+
+
+def _cell_bg(fig, xr, yr, fill, border):
+    """Fill the cell and outline it, spanning the full domain."""
+    fig.add_shape(type="rect", xref=xr, yref=yr,
+                  x0=0, x1=1, y0=0, y1=1, layer="below",
+                  fillcolor=as_plotly_color(fill),
+                  line=dict(color=border, width=1))
+
+
+def _scatter_cell(fig, r, c, xv, yv, fit, do_fit, px,
+                  pt_fill, pt_color, fit_color, fit_lwd, se_fill,
+                  band=True):
+    """Points, and (when fit is on) the fit line and, if band,
+    its 95% confidence band, in subplot (row r, col c)."""
+    from .XY import _loess, _plt_fit, _se_band
+
+    if do_fit and len(xv) >= 2:
+        if fit == "loess":
+            xs, _, f, se_f = _loess(xv, yv, 2 / 3)
+        else:                          # lm
+            xs, ys_s, f = _plt_fit(xv, yv, "lm", 1)
+        if band:
+            if fit == "loess":
+                tq = sps.t.ppf((1 + 0.95) / 2, len(xs) - 1)
+                poly = (np.concatenate([xs, xs[::-1]]),
+                        np.concatenate([f + tq * se_f,
+                                        (f - tq * se_f)[::-1]]))
+            else:
+                poly = _se_band(xs, ys_s, f, 0.95)
+            fig.add_trace(go.Scatter(
+                x=poly[0], y=poly[1], mode="none", fill="toself",
+                fillcolor=as_plotly_color(se_fill),
+                hoverinfo="skip", showlegend=False), row=r, col=c)
+
+    fig.add_trace(go.Scatter(
+        x=xv, y=yv, mode="markers",
+        marker=dict(symbol="circle", size=px, sizemode="diameter",
+                    color=make_trans(pt_fill, 0.9), opacity=1,
+                    line=dict(color=to_hex(pt_color), width=0.5)),
+        hoverinfo="x+y", showlegend=False), row=r, col=c)
+
+    if do_fit and len(xv) >= 2:
+        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_plotly.py

@@ -0,0 +1,216 @@
+# plt_plotly.py — analog of plt.plotly.R
+#
+# Renders the XY() scatterplot / time-series view. Deviations from
+# the R renderer, whose interface reflects the base-R path it
+# shares state with:
+#   - fit lines, SE bands, and ellipses arrive as prepared
+#     line/polygon coordinate lists (XY computes them), not as
+#     per-point vectors threaded through a shared data frame
+#   - bubble mode (size=) and the outlier/MD path are not ported:
+#     bubble displays are internal to Chart(), and outlier
+#     flagging awaits the accompanying-statistics port
+#   - a date x-axis uses plotly's native date ticks rather than
+#     pretty() tick vectors
+
+import numpy as np
+import plotly.graph_objects as go
+
+from .plotly_utils import (
+    as_plotly_color, axis_base, axis_num, get_tick_fmt, make_trans,
+    plot_border, plotly_style, sym_at, to_hex, x_grid, y_grid,
+)
+from .utils import get_option
+
+
+def _hover_fmt(xv, yv, x_lab, y_lab, digits_d, is_date):
+    """Hover template for one trace. R analog: .hover.fmt()"""
+    fmty = get_tick_fmt(yv, digits_d)
+    ypart = f"%{{y:{fmty}}}" if fmty else "%{y}"
+    if is_date:
+        x_lab, xpart = "Date", "%{x|%Y-%m-%d}"
+    else:
+        fmtx = get_tick_fmt(xv, digits_d)
+        xpart = f"%{{x:{fmtx}}}" if fmtx else "%{x}"
+    return (f"{x_lab}: {xpart}<br>{y_lab.strip()}: {ypart}"
+            "<extra></extra>")
+
+
+def plt_plotly(groups, by_name=None,
+               fill=("#324E5C",), border=None, shape="circle",
+               pt_size=1,
+               x_lab="", y_lab="", ax=None, gridT1=None,
+               gridT2=None, main=None, digits_d=2,
+               connect=False, is_date=False, pt_opacity=0.90,
+               area_polys=None,
+               fit_lines=None, fit_color=None, fit_lwd=None,
+               se_polys=None, se_fill=None,
+               ellipses=None, ellipse_fill=None,
+               ellipse_color=None, ellipse_lwd=1,
+               style_opts=None):
+    """Scatterplot / time-series renderer for XY().
+
+    groups: list of (name, x, y) — one entry, name None, when
+    there is no by variable. R analog: plt.plotly()
+    """
+    if style_opts is None:
+        style_opts = plotly_style()
+    if fit_color is None:
+        fit_color = get_option("fit_color", "#5C4032")
+    if fit_lwd is None:
+        fit_lwd = get_option("fit_lwd", 2)
+
+    n_grp = len(groups)
+    has_groups = n_grp > 1
+
+    def recycle(cols):
+        cols = (list(cols) if isinstance(cols, (list, tuple))
+                else [cols])
+        return [cols[i % len(cols)] for i in range(n_grp)]
+
+    fills = recycle(fill)
+    borders = fills if border is None else recycle(border)
+
+    fig = go.Figure()
+
+    # areas under/between time series: prepared polygons from
+    # XY() (ts_area_fill / ts_stack), drawn beneath the lines
+    if area_polys:
+        for pax, pay, pcol in area_polys:
+            fig.add_trace(go.Scatter(
+                x=pax, y=pay, mode="none", fill="toself",
+                fillcolor=pcol, hoverinfo="skip",
+                showlegend=False))
+
+    # points: pixel diameter, R's single/grouped scale factors
+    px = float(pt_size) * (6.5 if has_groups else 7.25)
+    if not np.isfinite(px) or px < 0:
+        px = 5
+    mode_pts = "lines+markers" if connect else "markers"
+    if connect and px == 0:
+        mode_pts = "lines"
+
+    for i, (nm, xv, yv) in enumerate(groups):
+        hover = _hover_fmt(xv, yv, x_lab, y_lab, digits_d, is_date)
+        if has_groups:
+            hover = hover.replace(
+                "<extra></extra>", f"<br>{by_name}: {nm}"
+                                   "<extra></extra>")
+        marker = dict(
+            symbol=sym_at(shape, i), size=px, sizemode="diameter",
+            color=make_trans(fills[i], pt_opacity), opacity=1,
+            line=dict(color=to_hex(borders[i]), width=1),
+        ) if "markers" in mode_pts else None
+        fig.add_trace(go.Scatter(
+            x=xv, y=yv, mode=mode_pts,
+            name=None if nm is None else str(nm),
+            legendgroup=None if nm is None else str(nm),
+            marker=marker,
+            line=(dict(color=to_hex(borders[i]), width=1.5)
+                  if connect else None),
+            hovertemplate=hover,
+            # connected series show a legend-only line sample below
+            showlegend=has_groups and not connect,
+        ))
+        if has_groups and connect and len(xv) >= 2:
+            fig.add_trace(go.Scatter(
+                x=xv[:2], y=yv[:2], mode="lines",
+                name=str(nm), legendgroup=str(nm),
+                line=dict(color=to_hex(borders[i]), width=1.5),
+                hoverinfo="skip", showlegend=True,
+            ))
+
+    # ellipses: border per group when grouped, else ellipse_color
+    if ellipses:
+        for k, (ex, ey) in enumerate(ellipses):
+            edge = (to_hex(borders[k]) if has_groups
+                    else to_hex(ellipse_color))
+            fig.add_trace(go.Scatter(
+                x=ex, y=ey, mode="lines",
+                line=dict(color=edge, width=ellipse_lwd),
+                fill="toself",
+                fillcolor=as_plotly_color(ellipse_fill),
+                hoverinfo="skip", showlegend=False,
+            ))
+
+    # SE bands under their fit lines
+    if se_polys:
+        for bx, bnd_y in se_polys:
+            fig.add_trace(go.Scatter(
+                x=bx, y=bnd_y, mode="none", fill="toself",
+                fillcolor=as_plotly_color(se_fill),
+                hoverinfo="skip", showlegend=False,
+            ))
+
+    # fit lines: single fit in fit_color; group fits in group hues
+    if fit_lines:
+        fmtx_all = np.concatenate([f["x"] for f in fit_lines])
+        fmtx = get_tick_fmt(fmtx_all, digits_d)
+        xpart = f"%{{x:{fmtx}}}" if fmtx else "%{x}"
+        for i, fl in enumerate(fit_lines):
+            if len(fl["x"]) < 2:
+                continue
+            fmty = get_tick_fmt(fl["y"], digits_d)
+            ypart = f"%{{y:{fmty}}}" if fmty else "%{y}"
+            nm = fl["name"]
+            single = nm is None
+            lbl = "Fit" if single else f"Fit ({nm})"
+            fig.add_trace(go.Scatter(
+                x=fl["x"], y=fl["y"], mode="lines",
+                name="Fit" if single else f"Fit: {nm}",
+                legendgroup="fit" if single else str(nm),
+                line=dict(
+                    color=(to_hex(fit_color) if single
+                           else to_hex(fills[i])),
+                    width=fit_lwd),
+                hovertemplate=(
+                    f"{x_lab}: {xpart}<br>{lbl}: {ypart}"
+                    "<extra></extra>"),
+                showlegend=True,
+            ))
+
+    # axes, grids, legend, background
+    if is_date:
+        ax_x = axis_base()
+        ax_x["title"]["text"] = x_lab
+        ax_x.update(showgrid=True,
+                    gridcolor=to_hex(style_opts["grid_col"]),
+                    gridwidth=1)
+        shapes = y_grid(gridT2) + plot_border()
+    else:
+        ax_x = axis_num(x_lab, ax["axT1"], ax["axL1"])
+        shapes = x_grid(gridT1) + y_grid(gridT2) + plot_border()
+    ax_y = axis_num(y_lab, ax["axT2"], ax["axL2"])
+
+    leg_color = to_hex(style_opts["lab_color"])
+    fig.update_layout(
+        xaxis=ax_x, yaxis=ax_y,
+        shapes=shapes,
+        template=None,
+        legend=dict(
+            title=dict(
+                text=by_name if has_groups else None,
+                font=dict(
+                    size=round(15 * get_option("lab_size", 1)),
+                    family="Arial", color=leg_color)),
+            font=dict(
+                size=round(16 * get_option("axis_size", 0.9)),
+                family="Arial", color=leg_color),
+            orientation="v", x=1.05, y=0.5,
+            xanchor="left", yanchor="middle",
+            bgcolor=to_hex(style_opts["window_fill"]),
+            bordercolor="#CCCCCC", borderwidth=1,
+            itemsizing="constant",
+        ),
+        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.99, yanchor="top",
+                       font=dict(size=title_size)),
+            margin=dict(t=round(title_size * 2.2)),
+        )
+    return fig

lessPy/plt_smooth.py

@@ -0,0 +1,170 @@
+# plt_smooth.py — analog of the form="smooth" branch of
+# plt.main.R (~795-808), which delegates to smoothScatter()
+#
+# form="smooth" for XY(): the 2-D binned kernel density of
+# <x, y> as a smoothed color raster, densities transformed by
+# z^smooth_power, with the smooth_points lowest-density points
+# overplotted. _bkde2d() ports KernSmooth::bkde2D() directly
+# (linear binning, separable normal kernel) with smoothScatter's
+# bandwidth, (q95 - q05)/25 per axis, so the density grid
+# matches R. Renderer conventions follow plt_plotly.py: fit
+# lines, SE bands, and data ellipses arrive as prepared
+# coordinates computed by XY(). Deviation: the fill ramp is
+# fixed at the default-theme clr.den, colorRampPalette(
+# c(window_fill, hcl(240, 80, 16))) — lessPy does not port
+# themes.
+
+import numpy as np
+import plotly.graph_objects as go
+from scipy import stats as sps
+from scipy.signal import fftconvolve
+
+from .plotly_utils import (
+    as_plotly_color, axis_num, get_tick_fmt, plot_border,
+    plotly_style, to_hex, x_grid, y_grid)
+from .utils import get_option
+
+# colorRampPalette(c("white", hcl(240, 80, 16))): the density
+# ramp of the default lessR theme (plt.main.R ~799)
+_RAMP = [[0, "#FFFFFF"], [1, "#0041A5"]]
+
+
+def _linbin2d(x, y, gx, gy):
+    """Linear binning: each point's weight split among its four
+    surrounding grid nodes. R analog: KernSmooth's linbin2D()"""
+    m1, m2 = len(gx), len(gy)
+    lx = (x - gx[0]) / (gx[1] - gx[0])
+    ly = (y - gy[0]) / (gy[1] - gy[0])
+    i, j = np.floor(lx).astype(int), np.floor(ly).astype(int)
+    rx, ry = lx - i, ly - j
+    g = np.zeros((m1, m2))
+    for di, wx in ((0, 1 - rx), (1, rx)):
+        for dj, wy in ((0, 1 - ry), (1, ry)):
+            ii, jj = i + di, j + dj
+            ok = (ii >= 0) & (ii < m1) & (jj >= 0) & (jj < m2)
+            np.add.at(g, (ii[ok], jj[ok]), (wx * wy)[ok])
+    return g
+
+
+def _bkde2d(x, y, h, n_grid, lims):
+    """Binned 2-D kernel density estimate on an n_grid x n_grid
+    grid over lims=(x_lo, x_hi, y_lo, y_hi), normal kernel with
+    sd h=(hx, hy) truncated at tau=3.4 sd.
+    R analog: KernSmooth::bkde2D()"""
+    tau = 3.4
+    gx = np.linspace(lims[0], lims[1], n_grid)
+    gy = np.linspace(lims[2], lims[3], n_grid)
+    g = _linbin2d(x, y, gx, gy)
+    kern = []
+    for (a, b), hh in (((lims[0], lims[1]), h[0]),
+                       ((lims[2], lims[3]), h[1])):
+        L = min(int(tau * hh * (n_grid - 1) / (b - a)),
+                n_grid - 1)
+        fac = (b - a) / (hh * (n_grid - 1))
+        half = sps.norm.pdf(np.arange(L + 1) * fac) / hh
+        full = np.concatenate([half[:0:-1], half])
+        kern.append(full / (full.sum() * fac * hh))
+    z = fftconvolve(g, np.outer(kern[0], kern[1]),
+                    mode="same") / len(x)
+    return gx, gy, np.clip(z, 0, None)
+
+
+def plt_smooth(xv, yv, smooth_points, smooth_size, smooth_power,
+               smooth_bins, x_lab, y_lab, main, digits_d,
+               ax, gridT1, gridT2, x_lim, y_lim,
+               fit_lines, fit_color, fit_lwd, se_polys, se_fill,
+               ellipses, ellipse_fill, ellipse_color,
+               ellipse_lwd):
+    """Smoothed-density display of the scatter of x and y with
+    the lowest-density points overplotted, plus the standard
+    scatter overlays. R analog: smoothScatter() via plt.main.R"""
+
+    # smoothScatter bandwidth and grid: data range extended by
+    # 1.5 * bandwidth per axis (the bkde2D default range.x)
+    h = []
+    for v in (xv, yv):
+        q05, q95 = np.percentile(v, [5, 95])
+        hh = (q95 - q05) / 25
+        h.append(hh if hh > 0 else 1.0)
+    gx, gy, z = _bkde2d(xv, yv, h, smooth_bins,
+                        (xv.min() - 1.5 * h[0],
+                         xv.max() + 1.5 * h[0],
+                         yv.min() - 1.5 * h[1],
+                         yv.max() + 1.5 * h[1]))
+    dens = z ** smooth_power           # compress the peaks
+
+    style_opts = plotly_style()
+    fig = go.Figure()
+
+    fmtx = get_tick_fmt(xv, digits_d)
+    fmty = get_tick_fmt(yv, digits_d)
+    xpart = f"%{{x:{fmtx}}}" if fmtx else "%{x}"
+    ypart = f"%{{y:{fmty}}}" if fmty else "%{y}"
+    fig.add_trace(go.Heatmap(
+        x=gx, y=gy, z=dens.T,
+        colorscale=_RAMP, zsmooth="best", showscale=False,
+        hovertemplate=(f"{x_lab}: {xpart}<br>{y_lab}: {ypart}"
+                       "<extra></extra>"),
+    ))
+
+    # the smooth_points points in the lowest-density grid cells
+    # overplot the raster (smoothScatter nrpoints selection)
+    n_pts = min(len(xv), int(np.ceil(smooth_points)))
+    if n_pts > 0:
+        ix = ((len(gx) - 1) * (xv - gx[0])
+              / (gx[-1] - gx[0])).astype(int)
+        iy = ((len(gy) - 1) * (yv - gy[0])
+              / (gy[-1] - gy[0])).astype(int)
+        sel = np.argsort(dens[ix, iy], kind="stable")[:n_pts]
+        px = 2 * float(smooth_size)    # pch="." speck
+        if not np.isfinite(px) or px <= 0:
+            px = 2
+        fig.add_trace(go.Scatter(
+            x=xv[sel], y=yv[sel], mode="markers",
+            marker=dict(symbol="circle", size=px,
+                        sizemode="diameter", color="#000000"),
+            hoverinfo="skip", showlegend=False))
+
+    # standard scatter overlays, as in plt_plotly
+    for ex, ey in ellipses or []:
+        fig.add_trace(go.Scatter(
+            x=ex, y=ey, mode="lines",
+            line=dict(color=to_hex(ellipse_color),
+                      width=ellipse_lwd),
+            fill="toself",
+            fillcolor=as_plotly_color(ellipse_fill),
+            hoverinfo="skip", showlegend=False))
+    for bx, bnd in se_polys or []:
+        fig.add_trace(go.Scatter(
+            x=bx, y=bnd, mode="none", fill="toself",
+            fillcolor=as_plotly_color(se_fill),
+            hoverinfo="skip", showlegend=False))
+    for fl in fit_lines or []:
+        if len(fl["x"]) < 2:
+            continue
+        fig.add_trace(go.Scatter(
+            x=fl["x"], y=fl["y"], mode="lines", name="Fit",
+            legendgroup="fit",
+            line=dict(color=to_hex(fit_color), width=fit_lwd),
+            hoverinfo="skip", showlegend=True))
+
+    ax_x = axis_num(x_lab, ax["axT1"], ax["axL1"])
+    ax_y = axis_num(y_lab, ax["axT2"], ax["axL2"])
+    ax_x["range"] = x_lim
+    ax_y["range"] = y_lim
+    fig.update_layout(
+        xaxis=ax_x, yaxis=ax_y,
+        shapes=x_grid(gridT1) + y_grid(gridT2) + plot_border(),
+        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.99, yanchor="top",
+                       font=dict(size=title_size)),
+            margin=dict(t=round(title_size * 2.2)))
+    return fig