plot-io 0.1.0__py3-none-any.whl

plot_io/series/contour.py

@@ -0,0 +1,294 @@
+"""Contours: iso-lines and filled bands of a grid of values."""
+
+import array
+import math
+from typing import Any
+
+from .. import _backend, stats
+from ..maps import ColorMap, check_cmap
+from ..numbers import NumberStyle, check_format, format_numbers, number_settings
+from ..scales import get_scale
+from ..settings import Setting, boolean, color, either, literal, number, one_of, table
+from ..shapes import fill_ring_sets
+from ..style import dash_of, with_alpha
+from ..text import Font, draw_text, measure
+from ..ticks import nice_step
+from . import Series, common
+from .heatmap import _Coords
+
+__all__ = ["Contour"]
+
+
+def _levels(v: Any) -> Any:
+    if isinstance(v, int) and not isinstance(v, bool):
+        return number(lo=1, integer=True)(v)
+    vals = sorted(float(x) for x in v)
+    if len(vals) < 1:
+        raise ValueError("give at least one level")
+    return vals
+
+
+def _colors(v: Any) -> Any:
+    if isinstance(v, (list, tuple)) and v and not (
+            len(v) in (3, 4) and all(isinstance(c, (int, float)) for c in v)):
+        return [color(c) for c in v]
+    return color(v)
+
+
+class Contour(Series):
+    """Contour lines and/or filled bands of ``values`` (rows first) at nodes ``x``/``y``
+    (centres; edges are reduced to their midpoints)."""
+
+    SETTINGS = table(
+        levels=Setting(_levels, doc="A number of levels (nice values over the data) or "
+                                        "the level values."),
+        filled=Setting(boolean, doc="Fill the bands between levels."),
+        lines=Setting(boolean, doc="Draw the iso-lines."),
+        color_map=Setting(check_cmap, inherited=True, doc="Color map of the levels."),
+        colors=Setting(_colors, doc="Line color, or one per level, instead of the map."),
+        line_width=Setting(number(lo=0), doc="Line width (pt).", length=True),
+        line_style=Setting(one_of("solid", "dashed", "dotted", "dashdot"),
+                           doc="Line style."),
+        negative_style=Setting(either(literal(None), one_of("solid", "dashed", "dotted",
+                                                            "dashdot")),
+                               doc="Line style of negative levels drawn with a single color "
+                                   "(matplotlib: dashed)."),
+        alpha=Setting(number(0, 1), doc="Opacity."),
+        labels=Setting(boolean, doc="Write the level values on the lines."),
+        label_format=Setting(check_format, doc="Number format of the labels."),
+        label_size=Setting(number(positive=True), doc="Label font size (pt).", length=True),
+        colorbar=Setting(either(literal(False), literal(True)),
+                         doc="Attach a colorbar to the plot."),
+        **common("name", "z", "rasterize", "simplify", "font_size", "font_family", "text_color"),
+        **number_settings(),
+    )
+    USES_PALETTE = False
+
+    def __init__(self, values: Any, x: Any = None, y: Any = None, plot: Any = None,
+                 **settings: Any) -> None:
+        from pdf_io import arrays as pdf_arrays
+        g = pdf_arrays.grid(values)
+        if g is not None:
+            self.h, self.w, k, self.flat = g
+            if k != 1:
+                raise ValueError("contour values must be a 2-D grid of numbers")
+        else:
+            rows = [list(r) for r in values]
+            self.h, self.w = len(rows), len(rows[0]) if rows else 0
+            if any(len(r) != self.w for r in rows):
+                raise ValueError("contour rows must have the same length")
+            self.flat = _backend.doubles([v for r in rows for v in r])
+        if self.h < 2 or self.w < 2:
+            raise ValueError("contours need a grid of at least 2 × 2 values")
+        self.xn = self._nodes(x, self.w, "x")
+        self.yn = self._nodes(y, self.h, "y")
+        self._map: Any = None
+        self._bar: Any = None
+        super().__init__(plot=plot, **settings)
+        if self.get("colorbar"):
+            self._bar = self.plot.colorbar(self)
+
+    @staticmethod
+    def _nodes(given: Any, n: int, what: str) -> array.array:
+        if given is None:
+            return array.array("d", (float(i) for i in range(n)))
+        c = _Coords(given, n, what)
+        if c.kind == "category":
+            raise ValueError("contour coordinates must be numbers")
+        v = c.values
+        if c.kind == "edges":
+            return array.array("d", ((a + b) / 2 for a, b in zip(v, v[1:])))
+        return array.array("d", v)
+
+    def _scales(self) -> tuple[Any, Any]:
+        out = []
+        for axis in (self.plot.x_axis, self.plot.y_axis):
+            name = axis.nominal_scale
+            out.append(get_scale("linear" if name == "category" else name))
+        return out[0], out[1]
+
+    # -- levels and map ---------------------------------------------------------------
+
+    def level_values(self) -> list[float]:
+        lv = self.get("levels")
+        if isinstance(lv, list):
+            return lv
+        n, lo, hi = _backend.extent(self.flat, None)
+        if not n:
+            return [0.0]
+        if hi == lo:
+            return [lo]
+        step = nice_step((hi - lo) / lv)
+        start = math.floor(lo / step + 1e-9) * step
+        end = math.ceil(hi / step - 1e-9) * step
+        k = int(round((end - start) / step))
+        return [round(start + i * step, 12) for i in range(k + 1)]
+
+    def color_map(self) -> ColorMap:
+        cmap = self.get("color_map")
+        lv = self.level_values()
+        key = (id(cmap) if isinstance(cmap, ColorMap) else repr(cmap), tuple(lv))
+        if self._map is None or self._map[0] != key:
+            base = cmap if isinstance(cmap, ColorMap) else ColorMap(cmap)
+            lim = (lv[0], lv[-1]) if len(lv) > 1 else (lv[0] - 0.5, lv[0] + 0.5)
+            self._map = (key, ColorMap(base, limits=lim))
+        return self._map[1]
+
+    def color_sources(self) -> list[tuple[Any, Any]]:
+        if self.get("colors") is not None and not self.get("filled"):
+            return []
+        return [(self.color_map(), array.array("d", self.level_values()))]
+
+    def has_own_color(self) -> bool:
+        return True
+
+    @property
+    def stats(self) -> dict[str, Any]:
+        """``{"levels", "lines": {level: [(x, y, closed)]}, "bands": [(lo, hi, (xs, ys,
+        ring_starts))]}``, coordinates after the axis scale functions."""
+        sx, sy = self._scales()
+        return self.cached(("stats", sx.name, sy.name), lambda: self._compute(sx, sy))
+
+    def _compute(self, sx: Any, sy: Any) -> dict[str, Any]:
+        lv = self.level_values()
+        fx = array.array("d", (sx.f(v) for v in self.xn))
+        fy = array.array("d", (sy.f(v) for v in self.yn))
+        lines: dict[float, Any] = {}
+        if self.get("lines"):
+            for level in lv:
+                lines[level] = stats.contour_lines(self.flat, self.w, self.h, fx, fy, level)
+        bands = []
+        if self.get("filled"):
+            for lo, hi in zip(lv, lv[1:]):
+                top = hi if hi != lv[-1] else math.nextafter(hi, math.inf)
+                rings = stats.contour_bands(self.flat, self.w, self.h, fx, fy, lo, top)
+                if len(rings[0]):
+                    bands.append((lo, hi, rings))
+        return {"levels": lv, "lines": lines, "bands": bands, "f_space": True}
+
+    # -- axes -------------------------------------------------------------------------
+
+    def values(self, role: str) -> Any:
+        return self.xn if role == "x" else self.yn
+
+    def zero_padding(self, role: str) -> bool:
+        return True
+
+    def occupy(self, ctx: Any, occ: Any) -> None:
+        self.occupy_all(ctx, occ)
+
+    def legend_points(self) -> tuple[Any, Any] | None:
+        return None
+
+    # -- drawing ----------------------------------------------------------------------
+
+    def _level_color(self, ctx: Any, i: int, level: float) -> Any:
+        given = self.get("colors")
+        if given is not None:
+            return ctx.color(given[i % len(given)] if isinstance(given, list) else given)
+        cmap = self.color_map()
+        flo, fhi = ctx.maps[id(cmap)][:2]
+        span = (fhi - flo) or 1.0
+        return cmap((level - flo) / span)
+
+    def draw(self, ctx: Any) -> None:
+        st = self.stats
+        canvas = ctx.canvas
+        alpha = self.get("alpha")
+        xm, ym = ctx.xmap, ctx.ymap
+
+        def px(v: Any) -> Any:
+            return _backend.scaled(v, xm.a, xm.b)
+
+        def py(v: Any) -> Any:
+            return _backend.scaled(v, ym.a, ym.b)
+
+        if st["bands"]:
+            cmap = self.color_map()
+            flo, fhi = ctx.maps[id(cmap)][:2]
+            span = (fhi - flo) or 1.0
+            sets, fills = [], []
+            for lo, hi, (xs, ys, starts) in st["bands"]:
+                sets.append((px(xs), py(ys), starts))
+                fills.append(with_alpha(cmap(((lo + hi) / 2 - flo) / span), alpha))
+            fill_ring_sets(canvas, sets, fills, simplify=self.simplify_arg())
+        lw = self.get("line_width")
+        if not st["lines"] or not lw:
+            return
+        style = self.get("line_style")
+        neg = self.get("negative_style")
+        single = self.get("colors") is not None and not isinstance(self.get("colors"), list)
+        self._drawn: list[tuple[float, Any, list[Any]]] = []
+        for i, level in enumerate(st["levels"]):
+            polylines = st["lines"].get(level) or []
+            if not polylines:
+                continue
+            c = with_alpha(self._level_color(ctx, i, level), alpha)
+            ls = neg if (neg is not None and single and level < 0) else style
+            xs = [px(p[0]) for p in polylines]
+            ys = [py(p[1]) for p in polylines]
+            canvas.draw_lines(xs, ys, color=c, width=lw, dash=dash_of(ls, lw),
+                              simplify=self.simplify_arg(lines=True))
+            self._drawn.append((level, c, list(zip(xs, ys))))
+
+    def draw_overlay(self, ctx: Any) -> None:
+        if not self.get("labels") or not getattr(self, "_drawn", None):
+            return
+        canvas = ctx.canvas
+        levels = [lv for lv, _, _ in self._drawn]
+        texts = format_numbers(levels, self.get("label_format"), NumberStyle.of(self))
+        size = self.get("label_size")
+        fig = self.plot.figure
+        bg = next((c for c in (self.plot.get("background"), fig.get("background"),
+                               fig.get("image_background")) if c is not None))
+        bg = ctx.color(bg)
+        x0, y0, x1, y1 = ctx.rect
+        for (level, c, lines), text in zip(self._drawn, texts):
+            font = Font(size, self.get("font_family"), color=c)
+            w, a, d = measure(canvas, text, font)
+            for xs, ys in lines:
+                n = len(xs)
+                if n < 3:
+                    continue
+                seg = [math.hypot(xs[i + 1] - xs[i], ys[i + 1] - ys[i]) for i in range(n - 1)]
+                total = sum(seg)
+                if total < 3 * w:
+                    continue
+                # the label goes at the middle of the line
+                half, acc, i = total / 2, 0.0, 0
+                while i < n - 2 and acc + seg[i] < half:
+                    acc += seg[i]
+                    i += 1
+                t = (half - acc) / seg[i] if seg[i] else 0.0
+                cx = xs[i] + t * (xs[i + 1] - xs[i])
+                cy = ys[i] + t * (ys[i + 1] - ys[i])
+                if not (x0 <= cx <= x1 and y0 <= cy <= y1):
+                    continue
+                ang = math.degrees(math.atan2(-(ys[i + 1] - ys[i]), xs[i + 1] - xs[i]))
+                if ang > 90:
+                    ang -= 180
+                elif ang < -90:
+                    ang += 180
+                if not self.get("filled"):
+                    canvas.save()
+                    canvas.translate(cx, cy)
+                    canvas.rotate(-ang)
+                    canvas.fill_style = bg
+                    pad = 0.25 * size
+                    canvas.fill_rect(-w / 2 - pad, -(a + d) / 2, w + 2 * pad, a + d)
+                    canvas.restore()
+                draw_text(canvas, text, cx, cy, font, "center", "center", ang)
+
+    def legend_colors(self, ctx: Any) -> tuple[Any, Any]:
+        lv = self.level_values()
+        c = self._level_color(ctx, len(lv) // 2, lv[len(lv) // 2])
+        return (c if self.get("filled") else None), c
+
+    def legend_glyph(self, ctx: Any, x: float, y: float, w: float, h: float) -> None:
+        fill, c = self.legend_colors(ctx)
+        if fill is not None:
+            ctx.canvas.fill_style = fill
+            ctx.canvas.fill_rect(x, y, w, h)
+        elif c is not None:
+            ctx.canvas.draw_lines([x, x + w], [y + h / 2, y + h / 2], color=c,
+                                  width=self.get("line_width"))

plot_io/series/curves.py

@@ -0,0 +1,128 @@
+"""Line and fill interpolation and missing values.
+
+pdf_io draws every mode in C (``interpolation=``, ``missing=`` on ``draw_lines`` and
+``fill_between``).  Horizontal fills are drawn here: their steps and skipped points are
+expanded by :func:`expand`, and curves are drawn as straight segments.
+"""
+
+import array
+import math
+from typing import Any
+
+from ..settings import Setting, one_of
+
+__all__ = ["INTERPOLATIONS", "curve_settings", "line_args", "expand"]
+
+INTERPOLATIONS = ("linear", "step-pre", "step-post", "step-mid", "monotone", "spline")
+
+
+def _interpolation(v: Any) -> str:
+    s = str(getattr(v, "value", v)).strip().lower().replace("_", "-")
+    if s not in INTERPOLATIONS:
+        raise ValueError(f"expected one of {', '.join(map(repr, INTERPOLATIONS))}, got {v!r}")
+    return s
+
+
+def curve_settings() -> dict[str, Setting]:
+    return {
+        "interpolation": Setting(
+            _interpolation,
+            doc="How points are joined: `linear`, `step-pre`, `step-post`, `step-mid`, "
+                "`monotone` (a curve that never overshoots) or `spline` (centripetal "
+                "Catmull–Rom)."),
+        "missing": Setting(one_of("break", "skip"),
+                           doc="Missing values: `break` the line there, or `skip` them and "
+                               "connect their neighbours."),
+    }
+
+
+def interpolation_of(series: Any) -> str:
+    return series.get("interpolation")
+
+
+def line_args(series: Any) -> dict[str, Any]:
+    """``interpolation``/``missing`` keywords for pdf_io's line and area calls."""
+    return {"interpolation": interpolation_of(series), "missing": series.get("missing")}
+
+
+def _runs(cols: list[Any], skip: bool) -> list[list[int]]:
+    n = len(cols[0])
+    ok = [all(math.isfinite(c[i]) if not isinstance(c, float) else True for c in cols)
+          for i in range(n)]
+    if skip:
+        return [[i for i in range(n) if ok[i]]]
+    runs: list[list[int]] = []
+    cur: list[int] = []
+    for i in range(n):
+        if ok[i]:
+            cur.append(i)
+        elif cur:
+            runs.append(cur)
+            cur = []
+    if cur:
+        runs.append(cur)
+    return runs
+
+
+def _step(xs: list[float], ys: list[list[float]], where: str) -> tuple[list[float], list[list[float]]]:
+    n = len(xs)
+    if n < 2:
+        return xs, ys
+    ox: list[float] = []
+    oy: list[list[float]] = [[] for _ in ys]
+    if where == "step-post":
+        for i in range(n - 1):
+            ox += [xs[i], xs[i + 1]]
+            for k, y in enumerate(ys):
+                oy[k] += [y[i], y[i]]
+        ox.append(xs[-1])
+        for k, y in enumerate(ys):
+            oy[k].append(y[-1])
+    elif where == "step-pre":
+        ox.append(xs[0])
+        for k, y in enumerate(ys):
+            oy[k].append(y[0])
+        for i in range(1, n):
+            ox += [xs[i - 1], xs[i]]
+            for k, y in enumerate(ys):
+                oy[k] += [y[i], y[i]]
+    else:
+        ox.append(xs[0])
+        for k, y in enumerate(ys):
+            oy[k].append(y[0])
+        for i in range(n - 1):
+            m = (xs[i] + xs[i + 1]) / 2
+            ox += [m, m]
+            for k, y in enumerate(ys):
+                oy[k] += [y[i], y[i + 1]]
+        ox.append(xs[-1])
+        for k, y in enumerate(ys):
+            oy[k].append(y[-1])
+    return ox, oy
+
+
+def expand(x: Any, ys: list[Any], interpolation: str, missing: str) -> tuple[Any, list[Any]]:
+    """Points for pdf_io versions without interpolation: missing points dropped (skip) or
+    runs separated by NaN (break), steps expanded per run.  Constant ``ys`` entries
+    (floats) stay constant."""
+    if interpolation == "linear" and missing == "break":
+        return x, ys
+    nan = math.nan
+    runs = _runs([x] + ys, missing == "skip")
+    ox = array.array("d")
+    oy: list[Any] = [array.array("d") if not isinstance(y, float) else y for y in ys]
+    for r_i, run in enumerate(runs):
+        if r_i:
+            ox.append(nan)
+            for k, y in enumerate(ys):
+                if not isinstance(y, float):
+                    oy[k].append(nan)
+        rx = [x[i] for i in run]
+        ry = [[y[i] if not isinstance(y, float) else y for i in run] for y in ys]
+        if interpolation.startswith("step"):
+            rx, ry = _step(rx, ry, interpolation)
+        ox.extend(rx)
+        for k, y in enumerate(ys):
+            if not isinstance(y, float):
+                oy[k].extend(ry[k])
+    return ox, oy

plot_io/series/ecdf.py

@@ -0,0 +1,143 @@
+"""Empirical cumulative distributions: a step line through the sorted values."""
+
+import array
+from typing import Any
+
+from .. import stats
+from ..settings import Setting, boolean, color, number, one_of, table
+from ..style import dash_of, with_alpha
+from . import Series, common
+from .hist import value_sets, _weights
+
+__all__ = ["Ecdf"]
+
+
+class Ecdf(Series):
+    """The empirical cumulative distribution of ``values`` (one array, or several as a dict
+    or a list of arrays)."""
+
+    SETTINGS = table(
+        weights=Setting(_weights, doc="A weight per value (per set for several sets)."),
+        stat=Setting(one_of("proportion", "count", "percent"),
+                     doc="`proportion` (0–1), `count` or `percent`."),
+        complementary=Setting(boolean, doc="Plot 1 − F (survival)."),
+        orientation=Setting(one_of("vertical", "horizontal"),
+                            doc="`vertical`: values along x; `horizontal`: along y."),
+        color=Setting(color, doc="Line color, or one per set; default palette colors."),
+        line_width=Setting(number(lo=0), inherited=True, doc="Line width (pt).", length=True),
+        line_style=Setting(one_of("solid", "dashed", "dotted", "dashdot"),
+                           doc="Line style."),
+        **common("name", "alpha", "z", "rasterize", "simplify", "font_size", "font_family",
+                 "text_color"),
+    )
+
+    def __init__(self, values: Any, plot: Any = None, **settings: Any) -> None:
+        self.sets, self.named = value_sets(values)
+        super().__init__(plot=plot, **settings)
+
+    def _horizontal(self) -> bool:
+        return self.get("orientation") == "horizontal"
+
+    @property
+    def stats(self) -> list[tuple[array.array, array.array, float]]:
+        """Per set: sorted values, the plotted cumulative values, and the value before the
+        first step (0, or the total for complementary curves)."""
+        return self.cached("stats", self._compute)
+
+    def _compute(self) -> list[tuple[array.array, array.array, float]]:
+        weights = self.get("weights")
+        st = self.get("stat")
+        out = []
+        for i, (key, v) in enumerate(self.sets):
+            w = None
+            if weights is not None:
+                w = (weights[key] if isinstance(weights, dict) else
+                     weights[i] if isinstance(weights, list) else weights)
+            xs, cs = stats.ecdf(v, w)
+            total = cs[-1] if len(cs) else 0.0
+            k = 1.0 if st == "count" else (100.0 if st == "percent" else 1.0) / (total or 1.0)
+            top = total * k
+            ys = array.array("d", (c * k for c in cs))
+            start = 0.0
+            if self.get("complementary"):
+                ys = array.array("d", (top - y for y in ys))
+                start = top
+            out.append((xs, ys, start))
+        return out
+
+    def values(self, role: str) -> Any:
+        val_role = "y" if self._horizontal() else "x"
+        out = array.array("d")
+        for xs, ys, start in self.stats:
+            if role == val_role:
+                out.extend(xs)
+            else:
+                out.extend(ys)
+                out.append(start)
+        return out
+
+    def palette_count(self) -> int:
+        return len(self.sets)
+
+    def has_own_color(self) -> bool:
+        return self.is_set("color")
+
+    def legend_labels(self) -> list[Any]:
+        if self.named:
+            return [str(k) for k, _ in self.sets]
+        name = self.get("name")
+        return [] if name is None else [name]
+
+    def _colors(self, ctx: Any) -> list[Any]:
+        c = self.get("color")
+        cols = [ctx.color(c)] * len(self.sets) if c is not None else self.auto_colors(ctx)
+        return [with_alpha(x, self.get("alpha")) for x in cols]
+
+    def draw(self, ctx: Any) -> None:
+        lw = self.get("line_width")
+        dash = dash_of(self.get("line_style"), lw)
+        horiz = self._horizontal()
+        for (xs, ys, start), col in zip(self.stats, self._colors(ctx)):
+            if not len(xs) or col is None:
+                continue
+            vx = array.array("d", [xs[0]])
+            vx.extend(xs)
+            cy = array.array("d", [start])
+            cy.extend(ys)
+            px, py = (cy, vx) if horiz else (vx, cy)
+            ctx.canvas.draw_lines(ctx.xmap.many(px), ctx.ymap.many(py), color=col, width=lw,
+                                  dash=dash, interpolation="step-pre" if horiz else "step-post",
+                                  simplify=self.simplify_arg(lines=True))
+
+    def occupy(self, ctx: Any, occ: Any) -> None:
+        from ..occupancy import MAX_VERTICES, thin
+        for xs, ys, start in self.stats:
+            if not len(xs):
+                continue
+            last_x, last_y = xs[-1], ys[-1]
+            xs, ys = thin(xs, ys, limit=MAX_VERTICES // 2)
+            vx = [xs[0]] + list(xs) + [last_x]
+            cy = [start] + list(ys) + [last_y]
+            sx, sy = [], []
+            for i in range(len(vx)):
+                if i:
+                    sx.append(vx[i])
+                    sy.append(cy[i - 1])
+                sx.append(vx[i])
+                sy.append(cy[i])
+            px, py = (sy, sx) if self._horizontal() else (sx, sy)
+            occ.lines(ctx.xmap.many(px), ctx.ymap.many(py))
+
+    def legend_colors_at(self, ctx: Any, i: int) -> tuple[Any, Any]:
+        cols = self._colors(ctx)
+        return None, cols[i] if i < len(cols) else None
+
+    def legend_glyph_at(self, ctx: Any, i: int, x: float, y: float, w: float, h: float) -> None:
+        _, c = self.legend_colors_at(ctx, i)
+        if c is not None:
+            lw = self.get("line_width")
+            ctx.canvas.draw_lines([x, x + w], [y + h / 2, y + h / 2], color=c, width=lw,
+                                  dash=dash_of(self.get("line_style"), lw))
+
+    def legend_glyph(self, ctx: Any, x: float, y: float, w: float, h: float) -> None:
+        self.legend_glyph_at(ctx, 0, x, y, w, h)

plot_io/series/errorbar.py

@@ -0,0 +1,111 @@
+"""Error bars on their own: bars (or a band) around points, with optional markers."""
+
+import array
+from typing import Any
+
+from .. import _backend
+from ..settings import Setting, color, number, one_of, table
+from ..style import with_alpha
+from . import Series, common
+from .errors import error_value
+from .points import MarkerStyle, marker_settings
+
+__all__ = ["Errorbar"]
+
+
+def _marker(v: Any) -> Any:
+    from ..markers import check_marker
+    return check_marker(v)
+
+
+class Errorbar(Series):
+    """Error bars at ``(x, y)``: ``y_error``/``x_error`` as a value, a sequence,
+    ``(low, high)`` or ``ErrorBars``; ``marker`` adds markers at the points."""
+
+    SETTINGS = table(
+        **{**marker_settings("marker_"),
+           "marker": Setting(_marker, doc="Marker at the points; default none.")},
+        color=Setting(color, doc="Bar color; default: the next palette color."),
+        line_width=Setting(number(lo=0), inherited=True, doc="Bar width (pt).", length=True),
+        cap=Setting(number(lo=0), doc="Cap width (pt); 0: no caps.", length=True),
+        x_error=Setting(error_value, doc="Horizontal errors."),
+        y_error=Setting(error_value, doc="Vertical errors."),
+        y_error_style=Setting(one_of("bars", "band"),
+                              doc="`bars`, or `band`: a filled band between the y error ends "
+                                  "(points sorted by x)."),
+        band_alpha=Setting(number(0, 1), doc="Opacity of a band."),
+        **common("name", "alpha", "z", "rasterize", "simplify", "font_size", "font_family",
+                 "text_color"),
+    )
+
+    def __init__(self, x: Any, y: Any, plot: Any = None, **settings: Any) -> None:
+        self.x, self.y = _backend.doubles(x), _backend.doubles(y)
+        if len(self.x) != len(self.y):
+            raise ValueError(f"x has {len(self.x)} values and y {len(self.y)}")
+        super().__init__(plot=plot, **settings)
+
+    def _error(self, role: str) -> Any:
+        e = self.get("x_error" if role == "x" else "y_error")
+        if e is not None:
+            e.bind(len(self.x))
+            if self.get("cap") != 3.0 and e.cap == 3.0:
+                e.cap = self.get("cap")
+        return e
+
+    def values(self, role: str) -> Any:
+        v = self.x if role == "x" else self.y
+        e = self._error(role)
+        if e is None:
+            return v
+        lo, hi = e.ends(v)
+        out = array.array("d", v)
+        out.extend(lo)
+        out.extend(hi)
+        return out
+
+    def legend_points(self) -> tuple[Any, Any]:
+        return self.x, self.y
+
+    def _color(self, ctx: Any) -> Any:
+        return with_alpha(self.base_color(ctx), self.get("alpha"))
+
+    def draw(self, ctx: Any) -> None:
+        c = self._color(ctx)
+        lw = self.get("line_width")
+        simplify = self.simplify_arg()
+        ey = self._error("y")
+        if ey is not None:
+            if self.get("y_error_style") == "band":
+                lo, hi = ey.ends(self.y)
+                order = sorted(range(len(self.x)), key=lambda i: self.x[i])
+                xs = array.array("d", (self.x[i] for i in order))
+                lo = array.array("d", (lo[i] for i in order))
+                hi = array.array("d", (hi[i] for i in order))
+                if c is not None:
+                    ctx.canvas.fill_between(ctx.xmap.many(xs), ctx.ymap.many(lo),
+                                            ctx.ymap.many(hi), color=c,
+                                            opacity=self.get("band_alpha"))
+            else:
+                ey.draw(ctx, self.x, self.y, False, c, lw, simplify, 1.0)
+        ex = self._error("x")
+        if ex is not None:
+            ex.draw(ctx, self.x, self.y, True, c, lw, simplify, 1.0)
+        if self.get("marker") is not None:
+            style = MarkerStyle(self, ctx, "marker_", c, len(self.x), False)
+            style.draw(ctx.canvas, ctx.xmap.many(self.x), ctx.ymap.many(self.y), simplify)
+
+    def legend_colors(self, ctx: Any) -> tuple[Any, Any]:
+        return None, self._color(ctx)
+
+    def legend_glyph(self, ctx: Any, x: float, y: float, w: float, h: float) -> None:
+        c = self._color(ctx)
+        if c is None:
+            return
+        canvas = ctx.canvas
+        lw = self.get("line_width")
+        cx = x + w / 2
+        canvas.draw_lines([cx, cx], [y, y + h], color=c, width=lw)
+        canvas.draw_segments([cx - 2, cx - 2], [y, y + h], [cx + 2, cx + 2], [y, y + h],
+                             color=c, width=lw)
+        if self.get("marker") is not None:
+            MarkerStyle(self, ctx, "marker_", c, 1, True).glyph(canvas, cx, y + h / 2, h * 0.8)