plot-io 0.12.0__py3-none-win_amd64.whl

plot_io/presets/_util.py

@@ -0,0 +1,153 @@
+"""What the presets share: per-category colors, legend entries, axis titles."""
+
+from typing import Any, Callable
+
+from ..color.values import desaturate
+from ..layers.core import Call, Entry
+from ..layers.paint import faded, memo
+from ..validators import typed
+
+__all__ = ["keyed", "columns_meta", "set_color_value", "fill_colors", "faded",
+           "per_category", "memo", "placed_text", "gradient_entry", "map_or_color",
+           "given_colors"]
+
+
+def keyed(call: Call, keys: dict[str, Any], flip: bool, tables: list[Any]) -> dict[str, Any]:
+    """Positions given as categories (``Columns.keys``): the categories of
+    the plot's axes, and the columns of ``tables`` placed at them once the axes are known
+    (``flip``: the data's x on the plot's y).  Returns the column functions by data
+    argument."""
+    out = {}
+    for name, k in keys.items():
+        role = name if not flip else ("y" if name == "x" else "x")
+        call.cats[role] = list(k.levels)
+
+        def column(ctx: Any, k: Any = k, role: str = role) -> Any:
+            return k.on((ctx.x if role == "x" else ctx.y).categories)
+
+        out[name] = column
+        for t in tables:
+            if name in t:
+                t.lazy[name] = column
+    return out
+
+
+def columns_meta(call: Call, roles: dict[str, str]) -> None:
+    """Axis titles from data column names and date axes from date data: ``roles`` maps
+    data arguments to the plot axis they are drawn on (``x`` and ``y`` map to
+    themselves unless given)."""
+    s = call.series
+
+    def role_of(param: str) -> str | None:
+        if param in roles:
+            return roles[param]
+        return param if param in ("x", "y") else None
+
+    for param, name in s.cols.titles.items():
+        role = role_of(param)
+        if role is not None:
+            call.titles.setdefault(role, name)
+    for param, tz in s.cols.times.items():
+        role = role_of(param)
+        if role is not None and role not in call.times:
+            call.times[role] = (True, tz)
+
+
+@typed("ColorLike | Sequence[ColorLike] | Mapping[Any, ColorLike]")
+def set_color_value(v: Any) -> Any:
+    """``color`` of a series of value sets: a color, one per set (a list), or a dict
+    ``{set name: color}``."""
+    from ..color.values import color
+    from ..layers.paint import colors_only
+    if isinstance(v, dict):
+        return {k: color(c) for k, c in v.items()}
+    return colors_only(v)
+
+
+def fill_colors(s: Any, ctx: Any, cols: list[Any]) -> list[Any]:
+    """The fills of items of colors ``cols`` (before saturation): ``fill``'s color in place
+    of each, ``saturation`` when the series has it, at ``fill_opacity`` times
+    ``opacity``."""
+    from .. import groups
+    fc, fa = groups.fill_parts(s)
+    if fc is not None:
+        cols = [ctx.color(fc)] * len(cols)
+    sat = s.resolve("saturation") if "saturation" in s.SETTINGS else 1.0
+    if sat != 1.0:
+        cols = [desaturate(x, sat) if x is not None else None for x in cols]
+    opacity = s.resolve("opacity")
+    return faded(cols, (1.0 if opacity is None else opacity) * fa)
+
+
+def per_category(s: Any, cats: list[Any], v: Any, what: str) -> list[Any]:
+    """Values per category of ``color``: a dict ``{category: value}`` or a list."""
+    if isinstance(v, dict):
+        return [v.get(k, float("nan")) for k in cats]
+    if len(v) != len(cats):
+        raise ValueError(f"{s.kind} setting 'color': {len(v)} values for {len(cats)} {what}")
+    return list(v)
+
+
+def placed_text(series: Any, key: Any, items: Callable[[Any], list[tuple[Any, ...]]],
+                font: Callable[[Any], Any], overlay: bool = True, **extra: Any) -> Any:
+    """A ``Text`` layer of labels placed once the axes are known: ``items(ctx)`` gives
+    ``(text, x, y, color, ha, va)`` in page units, optionally followed by ``angle``,
+    ``box`` and ``leader`` (see :class:`~plot_io.layers.geoms.Text`); its paint is the
+    ``text`` role (``font(ctx)`` and ``extra``)."""
+    from ..layers.core import Layer, Table
+    from ..layers.geoms import GEOMS
+    from ..layers.paint import Paint
+    names = ("text", "page_x", "page_y", "color", "ha", "va", "angle", "boxes", "leaders")
+    t = Table()
+
+    def column(k: int) -> Callable[[Any], Any]:
+        def get(ctx: Any) -> Any:
+            rows = memo(ctx, (key, "text"), lambda: items(ctx))
+            if all(len(r) <= k for r in rows):
+                return None
+            return [r[k] if len(r) > k else None for r in rows]
+        return get
+
+    for k, name in enumerate(names):
+        t.lazy[name] = column(k)
+    return Layer(GEOMS["text"], t, paint=Paint(series, "text", font=font, **extra),
+                 overlay=overlay, occupy=False, key=False, stat="identity",
+                 position="identity")
+
+
+def gradient_entry(series: Any, name: Any, cmap: Callable[[], Any]) -> Any:
+    """A legend entry whose symbol is the color map ``cmap()`` as a left-to-right gradient
+    (no symbol when it gives ``None``)."""
+    from ..layers.paint import Paint
+    return Entry(name, (("gradient", ()),), (Paint(series, "gradient", cmap=cmap),),
+                 Paint(series, "key"))
+
+@typed("ColorMap | str | Sequence[ColorLike] | ArrayLike | Callable[..., Any] | "
+       "Mapping[Any, ColorLike]")
+def map_or_color(v: Any) -> Any:
+    """The ``color_map`` of a pie or contour: a ``color_map`` value, or one color."""
+    from ..color.maps import check_color_map
+    from ..color.values import color
+    try:
+        return check_color_map(v)
+    except (TypeError, ValueError) as e:
+        try:
+            return color(v)
+        except (TypeError, ValueError):
+            raise e from None
+
+
+def given_colors(series: Any, n: int, kinds: tuple[str, ...] | None = None) -> Any:
+    """What a series' own ``color_map`` (:func:`map_or_color`) gives ``n`` items: one color,
+    or a list, the map's colors (``kinds``: only of a map of one of those kinds); ``None``:
+    ``"auto"``, or a map of another kind."""
+    from ..color.maps import MAP_WORDS, ColorMap, chosen_map, cycle_of
+    v = series.resolve("color_map")
+    if v is None or v == "auto":
+        return None
+    if not isinstance(v, ColorMap) and not (isinstance(v, str) and v in MAP_WORDS):
+        return v
+    cm = chosen_map(series, v, "qualitative")
+    if kinds is not None and cm.kind not in kinds:
+        return None
+    return list(cycle_of(cm, n))

plot_io/presets/area.py

@@ -0,0 +1,145 @@
+"""Stacked areas: layers piled on a baseline (zero, symmetric or streamgraph), each a
+``Band`` with its top as a ``Path``."""
+
+import array
+from typing import Any
+
+from .._methods import AreaMixin
+from .. import groups
+from ..color.values import with_alpha
+from ..layers import positions
+from ..layers.base import Series, common
+from ..layers.core import Table
+from ..layers.grammar import Lay, Spec
+from ..settings import Setting, boolean, one_of, table, text
+from ..transform import settings_both as coord_settings
+from ..layers.paint import base_colors
+from ._util import fill_colors, set_color_value
+from .curves import curve_settings
+
+__all__ = ["Area"]
+
+
+def _names(v: Any) -> Any:
+    """One text, or a tuple of texts (one per layer) from a list."""
+    if isinstance(v, (list, tuple)):
+        return tuple(text(n) for n in v)
+    return text(v)
+
+
+class Area(AreaMixin, Series):
+    """Areas of the layers ``y`` (one column, or several: a dict ``{name: values}``, a
+    data frame, a 2-D buffer's columns, a list of arrays) along ``x``, stacked on ``baseline``; ``orientation="horizontal"`` runs them along y.
+
+    Named layers get a legend entry each.  ``baseline``: ``zero``, ``sym``, ``wiggle`` or
+    ``weighted_wiggle`` (matplotlib's stackplot baselines).  ``fill_opacity`` is the fills'
+    opacity, ``opacity`` the whole series'.  ``interpolation`` and ``missing`` as
+    :class:`Fill`'s.
+
+    Example::
+
+        p = plt.Plot(width=240, height=160)
+        p.area(range(8), {"a": [1, 2, 3, 3, 4, 4, 5, 5], "b": [2, 2, 2, 3, 3, 2, 2, 3],
+                          "c": [1, 1, 2, 2, 1, 2, 3, 3]})
+    """
+
+    SETTINGS = table(
+        **coord_settings(),
+        baseline=Setting(one_of("zero", "sym", "wiggle", "weighted_wiggle"),
+                         doc="`zero`, `sym` (symmetric around 0), `wiggle` or "
+                             "`weighted_wiggle` (streamgraphs, as matplotlib's stackplot)."),
+        stack=Setting(boolean, doc="Stack the layers; `False` overlays them from 0."),
+        color=Setting(set_color_value,
+                      doc="A color, one per layer (a list, or a dict by layer name); default "
+                          "the plot's colors."),
+        **groups.FillStyle.embed(docs={"fill": "Fill: `True` (each layer's color), a color, or "
+                                               "`False`.",
+                                       "fill_opacity": "Opacity of the fill, times `opacity` "
+                                                       "(outlines keep `opacity`)."}),
+        **groups.Stroke.embed("edge_",
+                              only=("color", "line_width"),
+                              checks={"color": groups.series_color},
+                              docs={"color": "Outline color of each layer's top: a color, "
+                                             "`\"series\"` (each layer's own color) or none.",
+                                    "line_width": "Outline width; default the line width."}),
+        **curve_settings(),
+        orientation=Setting(one_of("vertical", "horizontal"),
+                            doc="`vertical` (layers along x) or `horizontal` (along y)."),
+        name=Setting(_names, doc="Legend entry: a text, or one per layer (a list); unset: "
+                                 "none (the keys of a dict of layers are entries)."),
+        **common("plain_color", "opacity", "z", "rasterize", "simplify", "font_size",
+                 "font_family", "text_color"),
+    )
+
+    DATA = {"x": "position", "y": "sets"}
+
+    def __init__(self, x: Any, y: Any, plot: Any = None, **settings: Any) -> None:
+        super().__init__(plot=plot, **settings)
+
+    @property
+    def ys(self) -> list[array.array]:
+        """The layers' heights: one column each."""
+        return self.cols.values
+
+    @property
+    def names(self) -> list[Any]:
+        """The layers' names (a dict's keys, a frame's columns, else 0, 1, …)."""
+        return [k for k, _ in self.cols.sets]
+
+    @property
+    def stats(self) -> list[tuple[array.array, array.array]]:
+        """``(bottom, top)`` of each layer."""
+        return self.cached("stats", self._compute, ("stack", "baseline"))
+
+    def _compute(self) -> list[tuple[array.array, array.array]]:
+        tables = _layers(self, None)
+        return [(t["bottom"], t["top"]) for t in tables]
+
+    def _colors(self, ctx: Any) -> list[Any]:
+        return base_colors(self, ctx, self.names, "layers")
+
+    def _fills(self, ctx: Any) -> list[Any]:
+        return fill_colors(self, ctx, self._colors(ctx))
+
+    def _strokes(self, ctx: Any) -> list[Any]:
+        """Each layer's outline color."""
+        ec = self.resolve("edge_color")
+        opacity = self.resolve("opacity")
+        out = []
+        for c in self._colors(ctx):
+            c = c if ec == "series" else ctx.color(ec)
+            out.append(with_alpha(c, 1.0 if opacity is None else opacity) if c is not None
+                       else None)
+        return out
+
+    SPEC = Spec(
+        [Lay("band", ("band", {"color": "_fills()",
+                               "extra": ("simplify", "interpolation", "missing")}),
+             table="layers", per_set=True, aes={"y1": "top", "y2": "bottom"},
+             position="stack"),
+         Lay("path", ("stroke", {"color": "_strokes()", "width": "edge_width",
+                                 "extra": ("interpolation", "missing")}),
+             table="layers", per_set=True, aes={"y": "top"}, occupy=False, glyph="top")],
+        tables={"layers": lambda s, b: _layers(s, b)},
+        entries="sets", key={"fill": "_fills()", "stroke": "_strokes()", "when": "edge_width"},
+        color_count="sets", items="layers", zero=lambda s: ("y",) if s.resolve("baseline") == "zero" else ())
+
+
+def _layers(s: Area, b: Any) -> list[Table]:
+    """A table per layer: ``x`` and its ``heights``, stacked on the baseline (in the
+    plot's positions; at once without a build) or from 0."""
+    x = s.cols["x"]
+    n = len(x)
+    out = []
+    for r in s.ys:
+        t = Table(x=x, heights=r)
+        if not s.resolve("stack"):
+            t["bottom"], t["top"] = array.array("d", bytes(8 * n)), array.array("d", r)
+        out.append(t)
+    if s.resolve("stack"):
+        if b is None:
+            positions.stack(out, baseline=s.resolve("baseline"))
+        else:
+            for t in out:
+                t.stack = (("area", id(s)), True, s.resolve("baseline"))
+    return out

plot_io/presets/bar.py

@@ -0,0 +1,261 @@
+"""Bars: one rectangle per category or x value (``Rects``), grouped (dodge) or stacked
+(stack), with error bars (``Segments``) and value labels (``Text``)."""
+
+import math
+from typing import Any
+
+from vec_io.arrays import doubles
+
+from .._methods import BarMixin
+from .. import groups
+from ..labels import bar_labels, check_labels, label_size
+from ..layers.base import common
+from ..layers.core import Layer, Table
+from ..layers.geoms import RECTS
+from ..layers.grammar import Lay, Spec, flipped
+from ..layers.paint import Paint, base_colors, role
+from ..layers.positions import Dodge, check_stack, slot_edges, slots
+from ..numbers import NumberStyle, check_format, format_numbers
+from ..color.values import color
+from ..settings import Setting, boolean, number, one_of, table
+from ..text import font_of
+from ..transform import settings_both as coord_settings
+from ..validators import length
+from ..values import category_paint
+from ._util import (faded, fill_colors, memo, placed_text)
+from .errors import Summarized, error_layers, error_value, errors_of
+
+__all__ = ["Bar"]
+
+
+def _bottom(v: Any) -> Any:
+    if isinstance(v, (int, float)) and not isinstance(v, bool):
+        return float(v)
+    return doubles(v)
+
+
+_width = length(positive=True, data=True, percent="slot")
+
+
+class Bar(BarMixin, Summarized):
+    """Bars of height ``y`` at ``x`` (categories or numbers), or of a dict
+    ``{category: height}``, or of heights alone (at 0, 1, …).
+
+    Categories make a category axis (``None`` among them: no bar there); numbers centre the
+    bars on them, ``width`` in data units.  ``value_labels`` writes the values outside,
+    inside or at the centre of the bars, formatted by ``value_label_format``; ``y_error``
+    adds error bars at the bar ends (along the value axis; ``error_color``, ``error_width``
+    style them).  Value axes include 0 (``include_zero="auto"``).  With replicates,
+    ``estimate`` and ``interval`` draw bars of their estimate with error bars of their
+    interval (`summaries <docs/api.md#summaries-estimate-interval>`_).  Bars share their category's slot with the plot's other bar
+    series (``dodge``, ``stack``: `series <docs/api.md#5-series>`_).
+
+    Example::
+
+        p = plt.Plot(width=240, height=160)
+        p.bar(["a", "b", "c", "d"], [3, 5, 2, 4], value_labels=True)
+    """
+
+    SETTINGS = table(
+        **coord_settings(),
+        color=Setting(category_paint,
+                      doc="Bar fill: a color, one per bar (list or dict by category), or "
+                          "numbers per bar (list or dict) mapped through `color_map`; "
+                          "default: the plot's next color."),
+        **common("color_map"),
+        **groups.Stroke.embed("edge_",
+                              only=("color", "line_width"),
+                              checks={"color": groups.series_color},
+                              docs={"color": "Outline color: a color, `\"series\"` (each "
+                                             "bar's own color, at `opacity`) or none.",
+                                    "line_width": "Outline width."}),
+        **groups.FillStyle.embed(docs={"fill": "Fill: `True` (each bar's color), a color, or "
+                                               "`False`.",
+                                       "fill_opacity": "Opacity of the fill, times `opacity` "
+                                                       "(outlines keep `opacity`)."}),
+        seam_color=Setting(color,
+                           doc="Where outlined bars touch (dodged or adjacent), the shared edge in "
+                               "this color; `none`: both outlines as drawn. Between the parts "
+                               "of a stack, the line is the outline of the part nearer the "
+                               "baseline."),
+        max_width=Setting(length(positive=True, data=True, percent="slot"),
+                          doc="Largest width of the series' part of a slot (as `width`); "
+                              "default none."),
+        width=Setting(_width,
+                      doc="Bar width: `%` of the slot, a length (bare numbers: px), `d` "
+                          "data units, or a duration (or `timedelta`) on time axes."),
+        bottom=Setting(_bottom, doc="Base of the bars: a value or one per bar."),
+        orientation=Setting(one_of("vertical", "horizontal"),
+                            doc="`vertical` (bars rise from the x axis) or `horizontal`."),
+        stack=Setting(check_stack,
+                      doc="`True`: on top of the previous stacked bars of the plot; "
+                          "`\"normalize\"`: stacks scaled to 1."),
+        dodge=Setting(boolean, doc="Bar series sharing a category share its slot side "
+                                         "by side; `False` overlays them."),
+        gap=Setting(length(lo=0, percent="slot_part"), doc="Fraction of each bar's part of a shared slot "
+                                           "left empty."),
+        saturation=Setting(number(0, 1), doc="Saturation of the fills (seaborn: 0.75)."),
+        y_error=Setting(error_value, doc="Error bars at the bar ends, along the value axis: "
+                                         "a value, a sequence, `(low, high)` or `Errors`."),
+        **common("estimate"),
+        **groups.Stroke.embed("error_",
+                              only=("color", "line_width"),
+                              docs={"color": "Error bar color.",
+                                    "line_width": "Error bar line width."}),
+        value_labels=Setting(check_labels,
+                             doc="Value labels: `True`/`\"outside\"`, `\"inside\"`, "
+                                 "`\"center\"`. Outside labels widen automatic limits so they "
+                                 "fit in the axes; a label too large for its bar goes outside, "
+                                 "or is left out on a stacked bar; a label over an earlier one "
+                                 "is left out."),
+        value_label_format=Setting(check_format, doc="Number format of the value labels."),
+        **common("name", "opacity", "z", "rasterize", "simplify", "font_size", "font_family",
+                 "text_color"),
+        **groups.NumberFormat.embed(),
+    )
+
+    DATA = {"x": "position", "y": "heights"}
+    ITEMS = "bars"
+
+    def __init__(self, x: Any, y: Any = None, plot: Any = None, **settings: Any) -> None:
+        super().__init__(plot=plot, **settings)
+
+    # -- paint -----------------------------------------------------------------------
+
+    def _colors(self, ctx: Any) -> list[Any]:
+        """Each bar's color, saturation applied, before opacity."""
+        return base_colors(self, ctx, self.cols.categories, "bars", items=True)
+
+    def fills(self, ctx: Any) -> list[Any]:
+        return fill_colors(self, ctx, base_colors(self, ctx, self.cols.categories, "bars",
+                                                    items=True, saturation=False))
+
+    def edges(self, ctx: Any) -> Any:
+        """Outline color: one, or one per bar (``edge_color="series"``); ``None``."""
+        if not self.resolve("edge_width"):
+            return None
+        v = self.resolve("edge_color")
+        if v != "series":
+            return ctx.color(v)
+        opacity = self.resolve("opacity")
+        opacity = 1.0 if opacity is None else opacity
+        return faded(self._colors(ctx), opacity)
+
+    # -- the preset --------------------------------------------------------------------
+
+    SPEC = Spec(
+        [Lay("rects", ("bar.rects", {"table": "#data"}), name="bars",
+             aes={"y0": "bottom", "y1": "top"},
+             position=lambda s: "stack" if s.resolve("stack") else "dodge", seams=True)],
+        tables={"data": lambda s, b: _bars(s, b)},
+        key={"fill": "symbol", "stroke": "symbol", "marker": "@bars"},
+        zero=("y",), titles={"x": "x", "y": "y", "values": "y"}, slots="x",
+        color_sources="items", finish=lambda s, b: _finish(s, b))
+
+    def _label_texts(self, t: Table) -> list[Any]:
+        vals = [b - a for a, b in zip(t["bottom"], t["top"])]
+        return format_numbers(vals, self.resolve("value_label_format"), NumberStyle.of(self))
+
+    def _label_items(self, ctx: Any, bars: Layer) -> list[Any]:
+        lay = bars.columns(ctx)
+        rects = RECTS.page_rects(ctx, lay)
+        fills = self.fills(ctx)
+        keep = [i for i, r in enumerate(rects) if all(math.isfinite(v) for v in r[:4])]
+        texts = self._label_texts(bars.table)
+        font = font_of(self, self.resolve("font_size"),
+                       color=ctx.color(self.resolve("text_color")))
+        return bar_labels(ctx.canvas, [rects[i] for i in keep], [texts[i] for i in keep],
+                          [fills[i] for i in keep], self.resolve("value_labels"), bars.flip, font,
+                          stacked=bool(self.resolve("stack")))
+
+    def _label_room(self, fonts: Any, role: str, t: Table,
+                    val: str) -> list[tuple[float, float, int]]:
+        """``(value, px, direction)`` per outside label on the value axis: the label needs
+        ``px`` past ``value``, toward higher (1) or lower (-1) values."""
+        if self.resolve("value_labels") != "outside" or role != val:
+            return []
+        texts = self._label_texts(t)
+        font = font_of(self, self.resolve("font_size"))
+        horizontal = flipped(self)
+        return [(top, label_size(fonts, text, font, horizontal), -1 if top < b else 1)
+                for b, top, text in zip(t["bottom"], t["top"], texts)
+                if text not in (None, "") and math.isfinite(top) and math.isfinite(b)]
+
+
+@role("bar.rects")
+def _rects_paint(s: Bar, ctx: Any, glyph: bool, table: Any = None) -> dict[str, Any]:
+    """The bars' fills and outlines (the legend's: the first bar's)."""
+    fills = memo(ctx, (id(table), "fills"), lambda: s.fills(ctx))
+    lc = memo(ctx, (id(table), "edges"), lambda: s.edges(ctx))
+    if glyph:
+        return {"fill": fills[0] if fills else None,
+                "stroke": lc[0] if isinstance(lc, list) and lc else
+                (None if isinstance(lc, list) else lc),
+                "line_width": s.resolve("edge_width")}
+    return {"fill": fills, "stroke": lc, "line_width": s.resolve("edge_width"),
+            "seam": ctx.color(s.resolve("seam_color")), "stack": bool(s.resolve("stack")),
+            "simplify": s.resolve("simplify")}
+
+
+def _bars(s: Bar, b: Any) -> Table:
+    """The bars: heights per category (stacked with the plot's stacked bars, or from
+    ``bottom``), in slots shared with the plot's dodged bars."""
+    flip = b.flip
+    time = "x" in s.cols.times
+    stack = s.resolve("stack")
+    t = Table(keys=list(s.cols.categories), heights=s.cols["y"])
+    d = Dodge(s, "bar", flip, list(s.cols.categories), s.cols["x"],
+              "stack" if stack else None, time)
+    t.dodge = d
+    if stack:
+        t.stack = (("bar", flip), stack)
+    else:
+        bottom = s.resolve("bottom")
+        n = len(s.cols["y"])
+        bottoms = [bottom] * n if isinstance(bottom, float) else list(bottom)
+        if len(bottoms) != n:
+            raise ValueError(f"{len(bottoms)} bottoms for {n} bars")
+        t["bottom"] = bottoms
+        t["top"] = [lo + h for lo, h in zip(bottoms, s.cols["y"])]
+
+    def ends(ctx: Any) -> list[tuple[float, float]]:
+        return memo(ctx, (id(t), "slot_edges"), lambda: slot_edges(d, ctx))
+
+    def x0(ctx: Any) -> list[float]:
+        return [a for a, _ in ends(ctx)]
+
+    def x1(ctx: Any) -> list[float]:
+        return [b for _, b in ends(ctx)]
+
+    t.lazy["x0"], t.lazy["x1"] = x0, x1
+    return t
+
+
+def _finish(s: Bar, b: Any) -> None:
+    """Error bars at the tops (after the plot's positions), value labels."""
+    call, flip = b.call, b.flip
+    t = b.tables["data"]
+    d = t.dodge
+    val = b.role("y")
+
+    def centers(ctx: Any) -> list[float]:
+        return [c for c, _ in memo(ctx, (id(t), "slots"), lambda: slots(d, ctx))]
+
+    def errors() -> None:
+        e = errors_of(s, "y_error")
+        if e is not None:
+            tops = t["top"]
+            e.bind(len(tops), s, "y_error")
+            source = Paint(s, "error_source", color="error_color", width="error_width",
+                           simplify=False, opacity=1.0)
+            call.layers[1:1] = error_layers(s, e, centers, tops, False, source, flip)
+        call.sticky_values[val] = sorted({v for v in t["bottom"] if math.isfinite(v)})
+
+    call.after.append(errors)
+    bars = call.layers[0]
+    if s.resolve("value_labels"):
+        call.layers.append(placed_text(s, id(s), lambda ctx: s._label_items(ctx, bars),
+                                       lambda ctx: font_of(
+                                           s, s.resolve("font_size"),
+                                           color=ctx.color(s.resolve("text_color")))))
+        call.room = lambda fonts, role: s._label_room(fonts, role, t, val)