plot-io 0.12.0__py3-none-win_amd64.whl

plot_io/geometry.py

@@ -0,0 +1,289 @@
+"""Geometry: a figure laid out, in px.
+
+The layout (:mod:`plot_io.layout`) measures each plot into :class:`Bands`: the axes
+rectangle surrounded by four stacks of bands (tick marks, tick labels, the ×10ᵏ offset,
+the axis label, twin axes, attached colorbars, an outside legend, the titles, the row
+label and group bands), each with a thickness and an overhang along the axes side.  Once the
+grid is solved, every area is placed into a frozen geometry record: rectangles, tick marks,
+text runs (:class:`plot_io.text.Run`), legend entries.  Drawing (:mod:`plot_io.render`)
+reads these records and the settings' colors and widths; it neither measures nor places.
+"""
+
+import dataclasses
+from typing import Any
+
+__all__ = ["Band", "Bands", "AxisGeometry", "PlotGeometry", "LegendGeometry", "LegendItem",
+           "BarGeometry", "ColorKeyGeometry", "KeyGeometry", "FigureColorbarGeometry",
+           "TitleGeometry", "FigureLegendGeometry",
+           "FigureGeometry", "dump", "GRID"]
+
+
+Segment = tuple[float, float, float, float]
+Rect = tuple[float, float, float, float]
+
+
+#: Marks a field left out of a :func:`dump` while it is empty (``None``, ``()``).
+_OPTIONAL = {"optional": True}
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Band:
+    """One band of a side stack: ``size`` px of the margin, ``pad`` px of gap then
+    ``extent`` px of content (``size`` is their sum), nominally ``offset`` px from the axes
+    edge; ``lo``/``hi``: how far its content passes the start/end of the side (left/right
+    of a top or bottom band, above/below a left or right band).  A band's offset is the sum
+    of the sizes before it on its side, except twin axes: the first on a side drawn at the
+    axes edge (offset 0), over the plot's mirrored ticks, a further one past the earlier."""
+
+    kind: str
+    offset: float
+    size: float
+    lo: float = 0.0
+    hi: float = 0.0
+    pad: float = 0.0
+    extent: float = 0.0
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Bands:
+    """What surrounds axes of ``size`` (w, h): the four stacks, from the axes outward, and
+    the margins (left, right, top, bottom) they take: each side's sizes summed, at least
+    the overhangs of the bands across it, plus the plot's ``space_above``; ``twins``:
+    the bands of the twin plots over the same axes (their margins are the ``twin`` bands)."""
+
+    size: tuple[float, float]
+    left: tuple[Band, ...] = ()
+    right: tuple[Band, ...] = ()
+    top: tuple[Band, ...] = ()
+    bottom: tuple[Band, ...] = ()
+    margins: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0)
+    twins: tuple["Bands", ...] = ()
+
+    def side(self, name: str) -> tuple[Band, ...]:
+        return getattr(self, name)
+
+    def extent(self, side: str, kinds: tuple[str, ...]) -> float:
+        """The sizes of the bands of ``kinds`` on ``side``, summed."""
+        return sum(b.size for b in self.side(side) if b.kind in kinds)
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class AxisGeometry:
+    """An axis as drawn: its tick mark groups (each stroked as one path: the ticks, then
+    the mirrored ones), tick label runs, title and ×10ᵏ offset runs."""
+
+    role: str
+    shown: bool = False
+    marks: tuple[tuple[Segment, ...], ...] = ()
+    labels: tuple[Any, ...] = ()
+    title: Any = None
+    offset: Any = None
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class LegendItem:
+    """A legend row: ``kind`` ``"header"`` (a size key's title), ``"size"`` (a size key
+    entry) or ``"entry"``; the symbol's box and the label run."""
+
+    kind: str
+    source: Any
+    index: int
+    glyph: Rect
+    label: Any
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class LegendGeometry:
+    """A legend's box ``(x, y, w, h)``, its title run and its rows."""
+
+    box: Rect
+    title: Any
+    items: tuple[LegendItem, ...]
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class BarGeometry:
+    """A colorbar drawn as a bar: the gradient's rectangle, extension blocks ``(rect, color)`` or
+    triangles ``(points, color)``, tick mark segments, tick label runs and the label run;
+    ``boxes``: the layout boxes of the colorbar and of its axis that their settings' ``%``
+    referred to when placed."""
+
+    state: Any
+    rect: Rect
+    blocks: tuple[tuple[Rect, Any], ...]
+    triangles: tuple[tuple[tuple[tuple[float, float], ...], Any], ...]
+    marks: tuple[Segment, ...]
+    labels: tuple[Any, ...]
+    title: Any
+    boxes: tuple[dict[str, float] | None, dict[str, float] | None]
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class ColorKeyGeometry:
+    """A colorbar drawn as a key: the bar's rectangle (round ends, the radius half its
+    thickness), the key's box (texts included), the end shapes ``(shape, geometry,
+    color)`` (``"dot"``: ``(cx, cy, r)``; ``"block"``: a rectangle; ``"triangle"``: its
+    points), the end text or tick label runs and the label run; ``boxes`` as a bar's."""
+
+    state: Any
+    rect: Rect
+    box: Rect
+    ends: tuple[tuple[str, Any, Any], ...]
+    values: tuple[Any, ...]
+    title: Any
+    boxes: tuple[dict[str, float] | None, dict[str, float] | None]
+    #: a size key's markers ``(cx, cy, diameter)``
+    marks: tuple[tuple[float, float, float], ...] = dataclasses.field(default=(),
+                                                                     metadata=_OPTIONAL)
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class KeyGeometry:
+    """A size legend in its own area: rows ``(kind, glyph box, label run)``."""
+
+    state: Any
+    rows: tuple[tuple[str, Rect, Any], ...]
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class TitleGeometry:
+    """A title as drawn: its ``side``, its ``lane`` (place in the side's stack, 0 nearest),
+    its box ``(x, y, w, h)``, its line runs and its rule's rectangle; a figure title on top
+    or bottom is a ``paragraph`` wrapped to its span instead of runs, drawn with its
+    top-left corner at ``at``."""
+
+    obj: Any
+    side: str
+    lane: int
+    box: Rect
+    runs: tuple[Any, ...]
+    rule: Rect | None = None
+    paragraph: Any = dataclasses.field(default=None, metadata=_OPTIONAL)
+    at: tuple[float, float] | None = dataclasses.field(default=None, metadata=_OPTIONAL)
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class FigureLegendGeometry:
+    """A figure legend as drawn: its ``side``, its ``lane`` (0 nearest the plots) and the
+    legend placed there."""
+
+    state: Any
+    side: str
+    lane: int
+    legend: LegendGeometry
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class FigureColorbarGeometry:
+    """A figure colorbar as drawn: its ``side``, its ``lane`` (0 nearest the plots) and the
+    colorbar placed there (a key or a bar)."""
+
+    side: str
+    lane: int
+    bar: Any
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class PlotGeometry:
+    """A plot (or a twin over it) as drawn: the axes rectangle, the bands it was measured
+    into, grid lines ``(axis, setting prefix, horizontal, positions)``, axis line segments
+    ``(axis, segment)``, the x and y axes, the twins, the row label runs, the main title's
+    run (a tuple of runs for several lines), the legend, the attached colorbars, the main
+    title's rule, the plot's other titles and the names of its interval lanes."""
+
+    state: Any
+    rect: Rect
+    bands: Bands
+    figure_size: tuple[float, float]
+    grid: tuple[tuple[Any, str, bool, tuple[float, ...]], ...]
+    spines: tuple[tuple[Any, Segment], ...]
+    x: AxisGeometry
+    y: AxisGeometry
+    twins: tuple["PlotGeometry", ...] = ()
+    row_label: tuple[Any, ...] = ()
+    title: Any = None
+    legend: LegendGeometry | None = None
+    bars: tuple[BarGeometry, ...] = ()
+    title_rule: Rect | None = dataclasses.field(default=None, metadata=_OPTIONAL)
+    titles: tuple[TitleGeometry, ...] = dataclasses.field(default=(), metadata=_OPTIONAL)
+    lane_names: tuple[Any, ...] = dataclasses.field(default=(), metadata=_OPTIONAL)
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class FigureGeometry:
+    """The figure's own parts: its title (a paragraph laid out ``title_width`` wide, its
+    box's top-left corner at ``title_at``), the rule above it, bands under the plots
+    ``(span, rect)``, lines over them ``(line, segment)``, the groups' runs, and the
+    figure's other titles, its legends and its colorbars, in the lanes between the plots."""
+
+    title: Any = None
+    title_at: tuple[float, float] = (0.0, 0.0)
+    title_width: float = 0.0
+    rule: Rect | None = None
+    spans: tuple[tuple[Any, Rect], ...] = ()
+    lines: tuple[tuple[Any, Segment], ...] = ()
+    groups: tuple[Any, ...] = ()
+    titles: tuple[TitleGeometry, ...] = dataclasses.field(default=(), metadata=_OPTIONAL)
+    legends: tuple[FigureLegendGeometry, ...] = dataclasses.field(default=(),
+                                                                  metadata=_OPTIONAL)
+    colorbars: tuple[FigureColorbarGeometry, ...] = dataclasses.field(default=(),
+                                                                      metadata=_OPTIONAL)
+
+
+#: Positions in :func:`dump` are rounded to 1/``GRID`` px.
+GRID = 64
+
+#: Fields of the records that hold render state (not geometry), left out of a dump; a
+#: run's shaped line (``glyphs``) is its ``content`` with its offsets.
+_STATE = frozenset({"state", "obj", "glyphs"})
+
+
+def dump(value: Any, grid: int = GRID) -> Any:
+    """``value`` (a :class:`~plot_io.layout.Geometry` or any of its records) as plain data
+    for comparison: dataclass records as dicts with their ``"type"``, numbers rounded to
+    1/``grid`` px, text runs with their plain text and font, model objects (axes, series,
+    decorations) by their class and role or name; render state left out."""
+    from vec_io.text import Paragraphs
+    from .text import Font, plain
+    if value is None or isinstance(value, (bool, str)):
+        return value
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float):
+        r = round(value * grid) / grid
+        return 0.0 if r == 0 else r
+    if dataclasses.is_dataclass(value) and not isinstance(value, type):
+        out: dict[str, Any] = {"type": type(value).__name__}
+        for f in dataclasses.fields(value):
+            if f.name in _STATE:
+                continue
+            v = getattr(value, f.name)
+            if f.metadata.get("optional") and (v is None or v == ()):
+                continue
+            out[f.name] = plain(v) if f.name == "content" else dump(v, grid)
+        if type(value).__name__ == "Placed":
+            out["area"] = _model(getattr(value, "obj"))
+        return out
+    if isinstance(value, Font):
+        return {"size": dump(value.size, grid), "family": value.family,
+                "weight": value.weight, "style": value.style, "color": dump(value.color, grid),
+                "stretch": value.stretch}
+    if isinstance(value, Paragraphs):
+        return {"type": "Paragraphs", "width": dump(value.width, grid),
+                "height": dump(value.height, grid),
+                "lines": [value.line_text(k) for k in range(value.lines)],
+                "baselines": dump(value.baselines, grid)}
+    if isinstance(value, (tuple, list)):
+        return [dump(v, grid) for v in value]
+    if isinstance(value, dict):
+        return {str(k): dump(v, grid) for k, v in value.items()}
+    return _model(value)
+
+
+def _model(obj: Any) -> Any:
+    """A model object (or another non-geometry value) by what names it."""
+    name = type(obj).__name__
+    role = getattr(obj, "role", None)
+    if isinstance(role, str):
+        return f"{name}:{role}"
+    return name

plot_io/groups.py

@@ -0,0 +1,308 @@
+"""Setting groups: settings that travel together, declared once.
+
+A group (:class:`Font`, :class:`TextStyle`, :class:`Stroke`, :class:`Marker`,
+:class:`FillStyle`, :class:`NumberFormat`) declares its members once.  An owner embeds it with
+:meth:`Group.embed` under a prefix: the primary element of the owner takes the group
+unprefixed (a scatter's markers: ``size``, ``edge_color``), a secondary one prefixed (a
+line's markers: ``marker_size``, ``marker_edge_color``).  Each member has its unprefixed
+name and the pattern of its prefixed name (``"{p}size"``).
+
+``"Group.member"`` keys (``"Marker.size"``, member names unprefixed) are defaults and style
+keys of every embedding of the member; an owner's own key (``"Line.marker_size"``) comes
+first.
+"""
+
+from collections.abc import Callable, Iterable
+from typing import Any
+
+from .color.values import color
+from .lines import line_style
+from .markers import MARKERS, check_marker
+from .numbers import _check_minus, _check_precision, _check_str
+from .settings import (MARKER_ALIASES, Setting, boolean, family, font_stretch, font_style,
+                       font_variations, font_weight, line_height, number, one_of)
+from .validators import Custom, length, typed
+from .values import paint, size_value
+
+__all__ = ["Group", "Member", "GROUPS", "series_color", "fill_value", "fill_parts", "Font",
+           "TextStyle", "Stroke", "Marker", "FillStyle", "NumberFormat"]
+
+#: Every group, by name.
+GROUPS: dict[str, type["Group"]] = {}
+
+
+def _constant(check: Any) -> Callable[[str], Any]:
+    def make(name: str) -> Any:
+        return check
+    return make
+
+
+class Member:
+    """One member of a group: its unprefixed ``name``, the ``pattern`` of its name under a
+    prefix ``{p}`` (a pattern without ``{p}`` is never prefixed), ``make(name)`` giving the
+    validator of a setting called ``name``, its doc and whether it is inherited."""
+
+    __slots__ = ("name", "pattern", "make", "doc", "inherited", "expr")
+
+    def __init__(self, name: str, check: Any, doc: str, pattern: str | None = None,
+                 inherited: bool = False, per_name: bool = False,
+                 expr: bool | None = None) -> None:
+        self.name = name
+        self.pattern = pattern if pattern is not None else "{p}" + name
+        self.make: Callable[[str], Any] = check if per_name else _constant(check)
+        self.doc = doc
+        self.inherited = inherited
+        self.expr = expr
+
+
+class Group:
+    """Base of setting groups."""
+
+    MEMBERS: dict[str, Member] = {}
+
+    def __init_subclass__(cls, **kw: Any) -> None:
+        super().__init_subclass__(**kw)
+        GROUPS[cls.__name__] = cls
+
+    @classmethod
+    def setting_name(cls, member: str, prefix: str = "") -> str:
+        """The name of ``member`` embedded under ``prefix``."""
+        if not prefix:
+            return member
+        return cls.MEMBERS[member].pattern.format(p=prefix)
+
+    @classmethod
+    def embed(cls, prefix: str = "", *, only: Iterable[str] | None = None,
+              docs: dict[str, str] | None = None,
+              inherited: Iterable[str] | bool | None = None,
+              checks: dict[str, Any] | None = None) -> dict[str, Setting]:
+        """The group's settings for a ``SETTINGS`` table: members ``only`` (default all),
+        under ``prefix``; ``docs`` and ``checks`` replace their
+        docs and validators, ``inherited`` (member names, or a bool for all) makes them
+        inherited or not."""
+        members = list(cls.MEMBERS) if only is None else list(only)
+        out: dict[str, Setting] = {}
+        for m in members:
+            mem = cls.MEMBERS[m]
+            name = cls.setting_name(m, prefix)
+            if inherited is None:
+                inh = mem.inherited
+            elif isinstance(inherited, bool):
+                inh = inherited
+            else:
+                inh = m in inherited
+            check = (checks or {}).get(m, None) or mem.make(name)
+            s = Setting(check, inherited=inh, doc=(docs or {}).get(m, mem.doc), expr=mem.expr)
+            s.group, s.field, s.prefix = cls, m, prefix
+            s.name = name
+            out[name] = s
+        return out
+
+    @classmethod
+    def member_setting(cls, member: str) -> Setting:
+        """A setting of ``member`` unprefixed (to check ``"Group.member"`` keys)."""
+        return cls.embed(only=[member])[member]
+
+
+# ---------------------------------------------------------------------------
+# The groups
+# ---------------------------------------------------------------------------
+
+_FONT_SIZE = length(positive=True, font=True, percent="em")
+
+
+class Font(Group):
+    """The face of text: size, family and variable-font axes (all inherited)."""
+
+    MEMBERS = {m.name: m for m in (
+        Member("font_size", _FONT_SIZE, "Base font size.", inherited=True),
+        Member("font_family", family, "Font family.", inherited=True),
+        Member("font_stretch", font_stretch,
+               "Font width: `normal`, `condensed`, …, or a percentage (`\"87.5%\"`); the "
+               "`wdth` axis of variable fonts.", inherited=True),
+        Member("font_variations", font_variations,
+               "Variable font axes: `{\"GRAD\": 50}` or `'\"GRAD\" 50, \"wght\" 650'`.",
+               inherited=True),
+        Member("font_optical_sizing", one_of("auto", "none"),
+               "`auto`: a variable font's `opsz` axis follows the font size; `none`.",
+               inherited=True),
+        Member("line_height", line_height,
+               "Height of a line of text: a multiple of the font size (`1.2`), a percentage "
+               "of it, or `normal` (the font's ascent and descent). Text boxes and the gaps "
+               "around them follow it, with the glyphs centered.", inherited=True),
+        Member("markup", boolean,
+               "Read markup in strings (`<b>`, `<i>`, `<sup>`, …: see "
+               "[conventions](#1-conventions)); `False`: strings stay literal.",
+               inherited=True),
+    )}
+
+    FACE = ("font_family", "font_stretch", "font_variations", "font_optical_sizing",
+            "line_height", "markup")
+
+
+
+class TextStyle(Group):
+    """One text element: size, weight, style and color."""
+
+    MEMBERS = {m.name: m for m in (
+        Member("font_size", _FONT_SIZE, "Font size.", pattern="{p}font_size"),
+        Member("font_weight", font_weight, "`normal`, `bold` or a weight 1–1000.",
+               pattern="{p}weight"),
+        Member("font_style", font_style,
+               "`normal`, `italic`, `oblique` or `\"oblique 10deg\"`.", pattern="{p}style"),
+        Member("color", color, "Text color."),
+    )}
+
+
+@typed("ColorLike")
+def series_color(v: Any) -> Any:
+    """A color, or ``"series"`` (the series' own color)."""
+    return v if v == "series" else color(v)
+
+
+class Stroke(Group):
+    """A stroke: color, width, dash style, caps and joins."""
+
+    MEMBERS = {m.name: m for m in (
+        Member("color", color, "Line color."),
+        Member("line_width", length(lo=0), "Line width.", pattern="{p}width"),
+        Member("line_style", line_style,
+               "`solid`, `dashed`, `dotted`, `dashdot` or a dash list.", pattern="{p}style"),
+        Member("cap", one_of("butt", "round", "square"), "Line cap."),
+        Member("join", one_of("miter", "round", "bevel"), "Line join."),
+    )}
+
+
+_PAINT = "ColorLike | Column | Density"
+
+
+def _paint(name: str) -> Any:
+    return typed(_PAINT)(lambda v: paint(v, name))
+
+
+def _edge_paint(name: str) -> Any:
+    return typed(_PAINT)(lambda v: v if v == "auto" else paint(v, name))
+
+
+def _marker_size(name: str) -> Any:
+    """``size`` maps numbers and densities (scatter, strip, swarm: a size axis); a secondary
+    group's ``marker_size`` is sizes in px."""
+    return size_value if name == "size" else _PX_SIZES
+
+
+@typed("SupportsFloat | str | Column | Density")
+def _px_sizes(v: Any) -> Any:
+    from .values import is_computed
+    out = size_value(v)
+    if is_computed(out):
+        raise ValueError("sizes in px: a density maps through a size axis, which only the "
+                         "`size` of scatter, strip and swarm has")
+    return out
+
+
+_PX_SIZES = Custom(_px_sizes, like=size_value)          # resolved as a length
+
+
+#: A marker name of the typed API: the built-in names and their shorthands.
+_MARKER_NAME = "Literal[" + ", ".join(map(repr, [*MARKERS, *MARKER_ALIASES])) + "]"
+
+
+@typed(f"{_MARKER_NAME} | Path | list[{_MARKER_NAME} | Path] | tuple[{_MARKER_NAME} | Path, ...]")
+def _marker_value(v: Any) -> Any:
+    if isinstance(v, (list, tuple)):
+        return [check_marker(m) for m in v]
+    return check_marker(v)
+
+
+@typed("bool | ColorLike")
+def fill_value(v: Any, colors: bool = True) -> Any:
+    """A ``fill``: ``True``, ``False`` (no fill) or (with ``colors``) a color; its opacity
+    is ``fill_opacity``."""
+    if v is True or v is False:
+        return v
+    if isinstance(v, (int, float)):
+        raise ValueError(f"expected True, False{' or a color' if colors else ''}, got {v!r} "
+                         "(an opacity is fill_opacity)")
+    if not colors:
+        raise ValueError(f"expected True or False, got {v!r}")
+    return color(v)
+
+
+class Marker(Group):
+    """Markers: shape, size (by area), fill and outline."""
+
+    MEMBERS = {m.name: m for m in (
+        Member("marker", _marker_value, "Marker name, `Path` or path data, or one per point.",
+               pattern="marker"),
+        Member("size", _marker_size,
+               "Marker size: the diameter of the circle of equal area; one value or one "
+               "per point; numbers per point are values to map when `size_map` is set; or "
+               "`\"density\"`.", per_name=True),
+        Member("color", _paint, "Fill: a color, colors per point, numbers per point "
+                                "(mapped through `color_map`) or `\"density\"`.",
+               per_name=True),
+        Member("edge_color", _edge_paint,
+               "Outline: as the fill color, or `\"auto\"` (white around filled markers; "
+               "hollow ones outlined in their color).", per_name=True),
+        Member("edge_width", length(lo=0), "Outline width; 0: no outline."),
+        Member("fill", typed("bool")(lambda v: fill_value(v, colors=False)),
+               "`True`: filled with the color; `False`: hollow, outlined in the color."),
+        Member("fill_opacity", number(0, 1),
+               "Opacity of the fill; below 1 the marker is also outlined in its color.",
+               pattern="{p}fill_opacity"),
+        Member("size_basis", one_of("area", "box"),
+               "`area`: shapes of the same size have the same area; `box`: size is the "
+               "width of the shape's box.", pattern="size_basis"),
+    )}
+
+    #: Docs of members under a prefix (a secondary element's markers, without a size axis).
+    PREFIXED_DOCS = {"size": "Marker size: the diameter of the circle of equal area, in px; "
+                             "one value or one per point."}
+
+    @classmethod
+    def embed(cls, prefix: str = "", **kw: Any) -> dict[str, Setting]:
+        if prefix:
+            kw["docs"] = {**cls.PREFIXED_DOCS, **(kw.get("docs") or {})}
+        return super().embed(prefix, **kw)
+
+
+def fill_parts(owner: Any, prefix: str = "") -> tuple[Any, float]:
+    """``(color, opacity)`` of an owner's ``fill`` and ``fill_opacity``: the color it gives
+    (``None``: the owner's) and the opacity it applies (0 without a fill)."""
+    v = owner.resolve(f"{prefix}fill")
+    if v is False or v is None:
+        return None, 0.0
+    op = owner.resolve(f"{prefix}fill_opacity")
+    return (None if v is True else v), (1.0 if op is None else op)
+
+
+class FillStyle(Group):
+    """A fill: on or off, or its color, and its opacity."""
+
+    MEMBERS = {m.name: m for m in (
+        Member("fill", fill_value,
+               "Fill: `True` (the owner's color), a color, or `False` (no fill)."),
+        Member("fill_opacity", number(0, 1), "Opacity of the fill (0–1).",
+               pattern="{p}fill_opacity"),
+    )}
+
+
+class NumberFormat(Group):
+    """How numbers are written (all inherited)."""
+
+    MEMBERS = {m.name: m for m in (
+        Member("decimal_separator", _check_str,
+               "Decimal separator of numbers (`\".\"`).", inherited=True),
+        Member("thousands_separator", _check_str,
+               "Thousands separator (`\"\"`: none).", inherited=True),
+        Member("minus", _check_minus,
+               "`hyphen` (`-`) or `minus` (U+2212, from an installed font).", inherited=True),
+        Member("prefix", _check_str,
+               "Text before every number.", inherited=True),
+        Member("suffix", _check_str,
+               "Text after every number.", inherited=True),
+        Member("precision", _check_precision,
+               "Significant digits of `auto`, `sci`, `eng`, `si` (unset: as needed); "
+               "`auto` tick labels keep enough decimals to differ.",
+               inherited=True),
+    )}