plot-io 0.12.0__py3-none-win_amd64.whl

plot_io/helpers/qq.py

@@ -0,0 +1,334 @@
+"""Quantile–quantile plots (stat ``qq``): a sorted sample against theoretical quantiles,
+or against another sample, with a reference line and a pointwise band of order
+statistics."""
+
+import array
+import bisect
+import math
+from typing import Any
+
+from .. import Scatter, ext, kernels
+from .._methods import QQMixin
+
+__all__ = ["QQ"]
+
+#: Quantile functions of the named distributions.
+DISTS: dict[str, Any] = {
+    "normal": ext.norm_quantile,
+    "uniform": lambda p: p,
+    "exponential": lambda p: -math.log1p(-p),
+}
+#: Ranks of the band at most.
+BAND_RANKS = 512
+
+
+def _dist(v: Any) -> Any:
+    if callable(v):
+        return v
+    return ext.one_of(*DISTS)(v)
+
+
+def _line(v: Any) -> Any:
+    if v is None or v is False:
+        return None
+    return ext.one_of("auto", "quartiles", "fit", "identity")(v)
+
+
+def _band(v: Any) -> Any:
+    if v is None or v is False or v == "auto":
+        return None if v is False else v
+    return ext.number(0, 1)(v)
+
+
+class QQ(QQMixin, Scatter):
+    """The sorted ``values`` against the quantiles of ``dist`` at R's ``ppoints``
+    (``(i − a) / (n + 1 − 2a)``, a = 3/8 for n ≤ 10, else 1/2), or against the sorted ``y``
+    (two samples: the longer interpolated to the shorter's size, as R's ``qqplot``;
+    ``values`` on x).  ``pvalues=True``: ``values`` are p-values, drawn as −log10 of the
+    sorted p-values (y) against −log10 of the expected uniform quantiles (x).  Points as
+    `Scatter`'s; the reference ``line`` and the pointwise ``band`` of order statistics in
+    the series color.  The points and the default line are R's (``qqnorm``, ``qqline``), not
+    scipy's ``probplot`` (Filliben's medians, a least-squares line).
+
+    ``dist``: ``normal`` (Wichura's AS241, full double precision), ``uniform``,
+    ``exponential``, or a function p → quantile.  With ``pvalues=True``, values outside
+    (0, 1] are left out.
+
+    - ``line``: ``quartiles`` (through the first and third quartile points, R's ``qqline``),
+      ``fit`` (least squares), ``identity``, or ``None``; ``"auto"``: ``identity`` with
+      ``pvalues``, else ``quartiles``.
+    - ``band``: the level of the pointwise band of order statistics (beta quantiles, mapped
+      through the line), on at most 512 ranks spread evenly along the sample axis;
+      ``"auto"``: 0.95 with ``pvalues``, else none.
+    - Markers have no edge by default.  Above 10,000 points with one marker style, points
+      within 1e-4 of the data range of the last one drawn are not drawn (``stats`` keeps
+      them all).
+
+    ``qq.stats``: ``x``, ``y``, ``line`` (slope, intercept), ``band_x``, ``low``, ``high``.
+    Uses::
+
+        p.qq(residuals)                                # against the normal, quartile line
+        p.qq(sample, other_sample)                     # two samples
+        p.qq(pvalues, pvalues=True)                    # genomics QQ: −log10, identity, 95 % band
+        p.qq(x, dist=scipy.stats.t(5).ppf, band=0.9)  # any quantile function
+
+    Example::
+
+        rng = random.Random(1)
+        p = plt.Plot(width=240, height=160)
+        p.qq([rng.gauss(0, 1) for _ in range(150)], band=0.95)
+    """
+
+    SETTINGS = ext.table(
+        **{k: v for k, v in Scatter.SETTINGS.items()
+           if k not in ("x_error", "y_error", "orientation") and not k.startswith("label")},
+        dist=ext.Setting(_dist, doc="`normal`, `uniform`, `exponential`, or a function "
+                                    "p → quantile (`scipy.stats.t(5).ppf`)."),
+        pvalues=ext.Setting(ext.boolean, doc="`values` are p-values: −log10 of both, the "
+                                             "identity line and a 95 % band by default."),
+        line=ext.Setting(_line, doc="`quartiles` (through the first and third quartiles, "
+                                    "R's `qqline`), `fit` (least squares), `identity`, "
+                                    "`None`; `auto`: `identity` with `pvalues`, else "
+                                    "`quartiles`."),
+        band=ext.Setting(_band, doc="Level of the pointwise band of order statistics (beta "
+                                    "quantiles, on the line), `None`; `auto`: 0.95 with "
+                                    "`pvalues`, else none."),
+        band_opacity=ext.Setting(ext.number(0, 1), doc="Opacity of the band."),
+        **ext.common("line_width"),
+    )
+
+    DATA = {"values": "numbers", "y": "raw"}
+
+    def __init__(self, values: Any, y: Any = None, plot: Any = None,
+                 **settings: Any) -> None:
+        ext.Series.__init__(self, plot=plot, **settings)
+
+    @property
+    def stats(self) -> dict[str, Any]:
+        """``x``, ``y`` (the points), ``line`` (``(slope, intercept)`` or ``None``), and the
+        band: ``band_x``, ``low``, ``high`` (``None`` without a band)."""
+        return ext.compute(self, "qq")
+
+    def density_points(self) -> tuple[Any, Any]:
+        st = self.stats
+        return st["x"], st["y"]
+
+
+def _sorted(values: Any, positive: bool = False) -> array.array:
+    """The finite values sorted (``positive``: those in (0, 1])."""
+    v = kernels.doubles(values)
+    s = kernels.take(v, kernels.argsort(v)) if len(v) else array.array("d")
+    i = 0
+    while i < len(s) and math.isnan(s[i]):
+        i += 1
+    lo = bisect.bisect_right(s, 0.0 if positive else -math.inf, i)
+    hi = bisect.bisect_right(s, 1.0, lo) if positive else bisect.bisect_left(s, math.inf, lo)
+    return s[lo:hi]
+
+
+def _ppoints(n: int) -> tuple[float, float]:
+    """``a`` and the denominator of R's ``ppoints(n)``."""
+    a = 3 / 8 if n <= 10 else 0.5
+    return a, n + 1 - 2 * a
+
+
+def _interpolated(s: array.array, n: int) -> array.array:
+    """Sorted ``s`` at ``n`` positions spread evenly over its ranks (``np.interp`` at
+    ``linspace(1, len, n)``)."""
+    m = len(s)
+    if n == 1 or m == 1:
+        return array.array("d", [s[0]] * n)
+    step = (m - 1) / (n - 1)
+    out = array.array("d")
+    for k in range(n):
+        t = 1 + k * step if k < n - 1 else float(m)
+        j = min(int(t) - 1, m - 2)
+        out.append((s[j + 1] - s[j]) * (t - (j + 1)) + s[j])
+    return out
+
+
+def _quartiles(xs: Any, ys: Any) -> tuple[float, float] | None:
+    (x1, x3), (y1, y3) = xs, ys
+    if not x3 - x1:
+        return None
+    slope = (y3 - y1) / (x3 - x1)
+    return slope, y1 - slope * x1
+
+
+def _fit(x: Any, y: Any) -> tuple[float, float] | None:
+    n = len(x)
+    if n < 2:
+        return None
+    mx, my = math.fsum(x) / n, math.fsum(y) / n
+    sxx = math.fsum((a - mx) * (a - mx) for a in x)
+    if not sxx:
+        return None
+    slope = math.fsum((a - mx) * (b - my) for a, b in zip(x, y)) / sxx
+    return slope, my - slope * mx
+
+
+def _band_ranks(n: int, along: Any) -> list[int]:
+    """At most :data:`BAND_RANKS` ranks (1-based), spread evenly along ``along`` (sorted
+    positions of the ranks, ascending or descending)."""
+    if n <= BAND_RANKS:
+        return list(range(1, n + 1))
+    sign = -1.0 if along[0] > along[-1] else 1.0
+    lo, hi = sign * along[0], sign * along[-1]
+    out: list[int] = []
+    for k in range(BAND_RANKS):
+        t = lo + (hi - lo) * k / (BAND_RANKS - 1)
+        i = min(bisect.bisect_left(along, t, key=lambda v: sign * v), n - 1) + 1
+        if not out or i > out[-1]:
+            out.append(i)
+    return out
+
+
+@ext.stat("qq", reads=("dist", "line", "band", "pvalues"))
+def _qq(cols: Any, p: Any, scales: Any = ()) -> dict[str, Any]:
+    pv = bool(p.get("pvalues"))
+    line, level = p.get("line", "auto"), p.get("band", "auto")
+    if line == "auto":
+        line = "identity" if pv else "quartiles"
+    if level == "auto":
+        level = 0.95 if pv else None
+    sample = _sorted(cols["values"], pv)
+    other = cols["y"]
+    n = len(sample)
+    out: dict[str, Any] = {"x": array.array("d"), "y": array.array("d"), "line": None,
+                           "band_x": None, "low": None, "high": None}
+    if not n:
+        return out
+    if other is not None:
+        ys = _sorted(other)
+        if not len(ys):
+            return out
+        xs = _interpolated(sample, len(ys)) if n > len(ys) else sample
+        ys = _interpolated(ys, n) if len(ys) > n else ys
+        out["x"], out["y"] = xs, ys
+        if line == "quartiles":
+            out["line"] = _quartiles(kernels.quantiles(sample, (0.25, 0.75)),
+                                     kernels.quantiles(_sorted(other), (0.25, 0.75)))
+        elif line == "fit":
+            out["line"] = _fit(xs, ys)
+        elif line == "identity":
+            out["line"] = (1.0, 0.0)
+        return out
+    a, den = _ppoints(n)
+    if pv:
+        q = kernels.scaled(array.array("d", range(1, n + 1)), 1 / den, -a / den)
+        out["x"] = kernels.scaled(q, -1.0, 0.0, "log10")
+        out["y"] = kernels.scaled(sample, -1.0, 0.0, "log10")
+        f = None
+    else:
+        f = p.get("dist", "normal")
+        f = DISTS[f] if isinstance(f, str) else f
+        out["x"] = array.array("d", (float(f((i - a) / den)) for i in range(1, n + 1)))
+        out["y"] = sample
+    x, y = out["x"], out["y"]
+    if line == "quartiles":
+        if f is None:
+            qx = [-math.log10(0.75), -math.log10(0.25)]
+        else:
+            qx = [float(f(0.25)), float(f(0.75))]
+        out["line"] = _quartiles(qx, kernels.quantiles(y, (0.25, 0.75)))
+    elif line == "fit":
+        out["line"] = _fit(x, y)
+    elif line == "identity":
+        out["line"] = (1.0, 0.0)
+    if level is None:
+        return out
+    slope, icpt = out["line"] or _quartiles(
+        [float(f(0.25)), float(f(0.75))] if f is not None else [0.0, 1.0],
+        kernels.quantiles(y, (0.25, 0.75))) or (1.0, 0.0)
+    ranks = _band_ranks(n, x if pv else y)
+    lows, highs, bx = array.array("d"), array.array("d"), array.array("d")
+    for i in ranks:
+        lo = ext.beta_quantile((1 - level) / 2, i, n + 1 - i)
+        hi = ext.beta_quantile((1 + level) / 2, i, n + 1 - i)
+        if f is None:
+            pair = (-math.log10(hi), -math.log10(lo))
+        else:
+            pair = (slope * float(f(lo)) + icpt, slope * float(f(hi)) + icpt)
+        lows.append(min(pair))
+        highs.append(max(pair))
+        bx.append(x[i - 1])
+    out["band_x"], out["low"], out["high"] = bx, lows, highs
+    return out
+
+
+#: Points of a QQ plot drawn whole at most; above, points closer to the last one kept than
+#: 1e-4 of the data's range on both axes (well under a pixel) are left out, when the
+#: markers are the same for every point.
+THIN = 10_000
+
+
+def _points(s: QQ, b: Any) -> Any:
+    return s.cached("qq_points", lambda: _thinned(s),
+                    ("dist", "line", "band", "pvalues", "color", "size", "marker",
+                     "edge_color"))
+
+
+def _thinned(s: QQ) -> Any:
+    st = s.stats
+    x, y = st["x"], st["y"]
+    n = len(x)
+    if not n:
+        return None
+    each = any(hasattr(v, "__len__") and not isinstance(v, str) and len(v) == n
+               for v in (s.resolve(k) for k in ("color", "size", "marker", "edge_color")))
+    if n <= THIN or each:
+        return ext.Table(x=x, y=y)
+    ex = (max(x) - min(x)) * 1e-4
+    ey = (max(y) - min(y)) * 1e-4
+    keep = array.array("q", [0])
+    lx, ly = x[0], y[0]
+    for i in range(1, n):
+        if abs(x[i] - lx) > ex or abs(y[i] - ly) > ey:
+            keep.append(i)
+            lx, ly = x[i], y[i]
+    if keep[-1] != n - 1:
+        keep.append(n - 1)
+    return ext.Table(x=kernels.take(x, keep), y=kernels.take(y, keep))
+
+
+def _line_table(s: QQ, b: Any) -> Any:
+    st = s.stats
+    if st["line"] is None or not len(st["x"]):
+        return None
+    slope, icpt = st["line"]
+    x0, x1 = min(st["x"]), max(st["x"])
+    if st["band_x"] is not None:
+        x0, x1 = min(x0, min(st["band_x"])), max(x1, max(st["band_x"]))
+    return ext.Table(line_x=[x0, x1], line_y=[slope * x0 + icpt, slope * x1 + icpt])
+
+
+def _band_table(s: QQ, b: Any) -> Any:
+    st = s.stats
+    if st["low"] is None:
+        return None
+    return ext.Table(x=st["band_x"], y1=st["low"], y2=st["high"])
+
+
+QQ.SPEC = ext.Spec(
+    [ext.Lay("band", ("band", {"color": "faded", "opacity": "band_opacity"}), table="band",
+             key=False),
+     ext.Lay("path", ("stroke", {"color": "faded"}), table="line",
+             aes={"x": "line_x", "y": "line_y"}, key=False, bounds=False),
+     ext.Lay("points", ("marker", {"order": True, "once": True,
+                                   "n": lambda s: _count(s)}),
+             table="points", name="points", radius=lambda s: _radius(s.resolve("size")))],
+    tables={"points": _points, "line": _line_table, "band": _band_table},
+    key={"fill": "marker", "stroke": "marker", "marker": "@points"},
+    color_sources=True, size_sources=True)
+
+
+def _count(s: QQ) -> int:
+    t = _points(s, None)
+    return 0 if t is None else len(t["x"])
+
+
+def _radius(size: Any) -> float:
+    return size / 2 if isinstance(size, (int, float)) else 0.0
+
+
+ext.register("qq", QQ)

plot_io/helpers/raincloud.py

@@ -0,0 +1,249 @@
+"""Raincloud plots: per category a half violin (the cloud), a narrow box at the slot's
+centre and the values as jittered points on the other side (the rain)."""
+
+import array
+import random
+from typing import Any
+
+from .. import columns, ext
+from .._methods import RaincloudMixin
+
+__all__ = ["Raincloud"]
+
+PARTS = ("violin", "box", "points")
+
+
+def _parts(v: Any) -> tuple[str, ...]:
+    if isinstance(v, str):
+        v = (v,)
+    out = tuple(v)
+    for p in out:
+        ext.one_of(*PARTS)(p)
+    return out
+
+
+class Raincloud(RaincloudMixin, ext.Series):
+    """Rainclouds of ``values`` (a dict ``{category: values}``, a list of arrays, or one
+    array; long data with ``x=`` categories): per category a half violin on the high side
+    (stat ``violin``), a narrow box at the centre (stat ``box``) and the values as
+    jittered points on the low side.  ``parts`` keeps some of the three.  Widths and
+    offsets are `%` of the slot.
+
+    Long data take ``x=`` the categories (``y=`` with ``orientation="horizontal"``).
+    Densities and quartiles are the ``violin`` and ``box`` stats.  Rainclouds do not dodge
+    with other series and take no levels.  The same halves and shifts work on the plain
+    types: ``Violin(side="high")``, ``Box(offset=…)``, ``Strip(offset=…)``.  Uses::
+
+        p.raincloud({"control": a, "treated": b})
+        p.raincloud("value", x="group", data=df, parts=("violin", "points"))
+
+    Example::
+
+        rng = random.Random(1)
+        p = plt.Plot(width=240, height=160)
+        p.raincloud({"control": [rng.gauss(0, 1) for _ in range(60)],
+                     "treated": [rng.gauss(1, 0.8) for _ in range(60)]})
+    """
+
+    SETTINGS = ext.table(
+        color=ext.Setting(ext.color, doc="Color of the three parts; default the next "
+                                         "plot's color."),
+        parts=ext.Setting(_parts, doc="The parts drawn: `violin`, `box`, `points`."),
+        orientation=ext.Setting(ext.one_of("vertical", "horizontal"),
+                                doc="`vertical` (categories on x) or `horizontal`."),
+        width=ext.Setting(ext.length(positive=True, data=True, percent="slot"),
+                          doc="Width of the slot the raincloud takes (the axis limits at "
+                              "numeric positions)."),
+        violin_width=ext.Setting(ext.length(positive=True, percent="slot"),
+                                 doc="Largest width of the half violins."),
+        box_width=ext.Setting(ext.length(positive=True, percent="slot"),
+                              doc="Width of the boxes."),
+        points_offset=ext.Setting(ext.length(percent="slot"),
+                                  doc="Centre of the points from the slot's centre "
+                                      "(negative: the low side)."),
+        jitter=ext.Setting(ext.length(lo=0, percent="slot"),
+                           doc="Half-width of the points' jitter."),
+        seed=ext.Setting(ext.number(integer=True), doc="Seed of the jitter."),
+        fill_opacity=ext.Setting(ext.number(0, 1), doc="Opacity of the violins' and "
+                                                       "boxes' fill."),
+        bandwidth=ext.Setting(ext.either(ext.one_of("scott", "silverman"),
+                                         ext.number(positive=True)),
+                              doc="`scott`, `silverman` or a number."),
+        adjust=ext.Setting(ext.number(positive=True), doc="Factor applied to the bandwidth."),
+        cut=ext.Setting(ext.number(lo=0), doc="The density extends this many bandwidths "
+                                              "past the data."),
+        points=ext.Setting(ext.number(lo=16, hi=65536, integer=True),
+                           doc="Points per violin outline."),
+        whiskers=ext.Setting(ext.number(lo=0), doc="Whisker reach in IQRs."),
+        weights=ext.Setting(columns.weights,
+                            doc="A weight per value, counted as repeated values, for the "
+                                "violins and boxes (a dict or a list per category, as the "
+                                "values; long data: a weight per row)."),
+        median_width=ext.Setting(ext.length(lo=0), doc="Width of the median line."),
+        **ext.group("Marker", "marker_"),
+        categories=ext.Setting(ext.either(ext.literal(None), lambda v: list(v)),
+                               doc="Category names of a list of arrays."),
+        **ext.common("line_width", "name", "opacity", "z", "rasterize", "simplify", "font_size",
+                     "font_family", "text_color"),
+    )
+    DATA = {"values": "categories", "positions": "slots"}
+    ITEMS = "rainclouds"
+
+    def __init__(self, values: Any, positions: Any = None, plot: Any = None,
+                 **settings: Any) -> None:
+        super().__init__(plot=plot, **settings)
+
+    def value_scale(self) -> Any:
+        return ext.axis_scale(ext.axis_of(self, "y"))
+
+    @property
+    def stats(self) -> dict[Any, dict[str, Any]]:
+        """``{category: {"violin": the violin stat's, "box": BoxStats}}``."""
+        v = ext.compute(self, "violin", (self.value_scale(),))
+        b = ext.compute(self, "box")
+        return {k: {"violin": v[k], "box": b[k]} for k in self.cols.categories}
+
+    def base(self, ctx: Any) -> Any:
+        """The series color."""
+        c = self.resolve("color")
+        return ctx.color(c) if c is not None else ext.auto_colors(self, ctx)[0]
+
+    def fill(self, ctx: Any) -> Any:
+        """The violins' and boxes' fill."""
+        return ext.with_alpha(self.base(ctx),
+                              self.resolve("opacity") * self.resolve("fill_opacity"))
+
+    def _on(self, part: str) -> bool:
+        return part in self.resolve("parts")
+
+    def _scale(self) -> Any:
+        """The scale of numeric positions' axis (``None``: none, or linear)."""
+        if self.cols["positions"] is None:
+            return None
+        sc = ext.axis_scale(ext.axis_of(self, "x"))
+        return sc if sc.function else None
+
+    def _slots(self) -> tuple[list[float], float]:
+        """The centre of each category's slot and the slot's width, in the space of the
+        positions' axis scale (:meth:`_back` maps them to data)."""
+        pos = self.cols["positions"]
+        if pos is None:
+            return [float(i) for i in range(len(self.cols.categories))], 1.0
+        sc = self._scale()
+        fs = [sc.f(float(p)) if sc is not None else float(p) for p in pos]
+        ps = sorted(set(fs))
+        gaps = [b - a for a, b in zip(ps, ps[1:]) if b > a]
+        return fs, (min(gaps) if gaps else 1.0)
+
+    def _back(self, v: Any) -> Any:
+        """Slot-space positions in data units."""
+        sc = self._scale()
+        if sc is None:
+            return v
+        if isinstance(v, list) and v and not isinstance(v[0], float):
+            return [self._back(a) for a in v]
+        return array.array("d", (sc.inverse(x) for x in v))
+
+    def _width(self, name: str, unit: float) -> float:
+        return float(self.resolve(name, of=unit))
+
+
+def _clouds(s: Raincloud, b: Any) -> Any:
+    st = s.stats
+    centres, unit = s._slots()
+    keys = [i for i, k in enumerate(s.cols.categories)
+            if st[k]["violin"]["count"] and not st[k]["violin"]["line"]]
+    if not keys:
+        return None
+    peak = max(max(st[s.cols.categories[i]]["violin"]["density"]) for i in keys) or 1.0
+    w = s._width("violin_width", unit)
+    xs, lo, hi = [], [], []
+    for i in keys:
+        v = st[s.cols.categories[i]]["violin"]
+        c = centres[i]
+        xs.append(v["grid"])
+        lo.append(array.array("d", [c] * len(v["grid"])))
+        hi.append(array.array("d", (c + d / peak * w for d in v["density"])))
+    return ext.Table(x=xs, y1=s._back(lo), y2=s._back(hi))
+
+
+def _boxes(s: Raincloud, b: Any) -> Any:
+    st = s.stats
+    centres, unit = s._slots()
+    half = s._width("box_width", unit) / 2
+    rows = [(centres[i], st[k]["box"]) for i, k in enumerate(s.cols.categories)
+            if st[k]["box"].count]
+    if not rows:
+        return None
+    return ext.Table(x0=s._back([c - half for c, _ in rows]),
+                     x1=s._back([c + half for c, _ in rows]),
+                     y0=[bs.q1 for _, bs in rows], y1=[bs.q3 for _, bs in rows])
+
+
+def _whiskers(s: Raincloud, b: Any) -> Any:
+    st = s.stats
+    centres, _ = s._slots()
+    t: dict[str, list[float]] = {"x0": [], "x1": [], "y0": [], "y1": []}
+    for i, k in enumerate(s.cols.categories):
+        bs = st[k]["box"]
+        if bs.count:
+            for a, e in ((bs.q1, bs.low), (bs.q3, bs.high)):
+                t["x0"].append(centres[i])
+                t["x1"].append(centres[i])
+                t["y0"].append(a)
+                t["y1"].append(e)
+    if not t["x0"]:
+        return None
+    return ext.Table(x0=s._back(t["x0"]), x1=s._back(t["x1"]), y0=t["y0"], y1=t["y1"])
+
+
+def _medians(s: Raincloud, b: Any) -> Any:
+    st = s.stats
+    centres, unit = s._slots()
+    half = s._width("box_width", unit) / 2
+    rows = [(centres[i], st[k]["box"].median) for i, k in enumerate(s.cols.categories)
+            if st[k]["box"].count]
+    if not rows:
+        return None
+    return ext.Table(x0=s._back([c - half for c, _ in rows]),
+                     x1=s._back([c + half for c, _ in rows]),
+                     y0=[m for _, m in rows], y1=[m for _, m in rows])
+
+
+def _rain(s: Raincloud, b: Any) -> Any:
+    centres, unit = s._slots()
+    off = s._width("points_offset", unit)
+    jit = s._width("jitter", unit)
+    rng = random.Random(s.resolve("seed"))
+    x, y = array.array("d"), array.array("d")
+    for c, vals in zip(centres, s.cols.values):
+        for v in vals:
+            x.append(c + off + jit * rng.uniform(-1.0, 1.0))
+            y.append(v)
+    return ext.Table(x=s._back(x), y=y) if len(y) else None
+
+
+@ext.role("raincloud.box")
+def _box_paint(s: Raincloud, ctx: Any, glyph: bool) -> dict[str, Any]:
+    return {"fill": s.fill(ctx), "stroke": ext.with_alpha(s.base(ctx), s.resolve("opacity")),
+            "line_width": s.resolve("line_width")}
+
+
+Raincloud.SPEC = ext.Spec(
+    [ext.Lay("band", ("band", {"color": "fill()", "extra": ("simplify",)}),
+             table="clouds", when=lambda s: s._on("violin"), turn=True, key=False),
+     ext.Lay("segments", ("stroke", {"color": "faded"}), table="whiskers",
+             when=lambda s: s._on("box"), key=False),
+     ext.Lay("rects", "raincloud.box", table="boxes", when=lambda s: s._on("box"),
+             key=False),
+     ext.Lay("segments", ("stroke", {"color": "faded", "width": "median_width"}),
+             table="medians", when=lambda s: s._on("box"), key=False),
+     ext.Lay("points", ("marker", {"prefix": "marker_", "color": "base",
+                                   "n": lambda s: sum(map(len, s.cols.values))}),
+             table="rain", name="rain", when=lambda s: s._on("points"))],
+    tables={"clouds": _clouds, "boxes": _boxes, "whiskers": _whiskers, "medians": _medians,
+            "rain": _rain},
+    key={"fill": "base", "stroke": "base"},
+    titles={"values": "y", "categories": "x"}, slots="positions")
+
+ext.register("raincloud", Raincloud)