plot-io 0.1.0__py3-none-any.whl

plot_io/axis.py

@@ -0,0 +1,574 @@
+"""Axes: settings (:class:`Axis`) and their state while a figure is drawn
+(:class:`AxisState`: scale, limits, ticks, mapping to the page)."""
+
+import math
+from collections.abc import Sequence
+from typing import Any
+
+from . import _backend
+from .limits import check_limits, needs_quantiles, resolve_limits
+from .scales import AXIS_SCALES, Scale, get_scale
+from .settings import (Setting, Settings, boolean, color, either, literal, number, one_of,
+                       pair, table, text)
+from .text import Font, box
+from .numbers import NumberStyle, check_format, format_axis, number_settings
+from .ticks import Tick, minor_linear, numeric_ticks
+
+__all__ = ["Axis", "AxisState", "Mapper"]
+
+
+def _ticks_value(v: Any) -> Any:
+    if v is False:
+        return False
+    if isinstance(v, (list, tuple)):
+        return [float(x) if not isinstance(x, str) else x for x in v]
+    raise ValueError(f"expected False or a list of values, got {v!r}")
+
+
+def _minor_value(v: Any) -> Any:
+    if isinstance(v, bool):
+        return v
+    if isinstance(v, (list, tuple)):
+        return [float(x) for x in v]
+    raise ValueError(f"expected True, False or a list of values, got {v!r}")
+
+
+def _rotation(v: Any) -> Any:
+    if v == "auto":
+        return "auto"
+    return number(-180, 180)(v)
+
+
+def _dash(v: Any) -> Any:
+    if isinstance(v, (list, tuple)):
+        return [number(lo=0)(x) for x in v]
+    return one_of("solid", "dashed", "dotted", "dashdot")(v)
+
+
+class Axis(Settings):
+    """An axis of a plot (``plot.x_axis``, ``plot.y_axis``) or of a colorbar."""
+
+    @property
+    def nominal_scale(self) -> str:
+        """``scale``, or ``"linear"`` while unset (before it is detected from the data)."""
+        s = self.get("scale")
+        return "linear" if s is None else s
+
+    SETTINGS = table(
+        label=Setting(text, doc="Axis title: a string or rich content."),
+        label_size=Setting(number(positive=True),
+                           doc="Font size of the label (pt); default: the base font size.", length=True),
+        scale=Setting(one_of(*AXIS_SCALES),
+                      doc="`linear`, `log`, `log2`, `log10`, `sqrt`, `exp`, `symlog`, "
+                          "`logit`, `time` or `category`; default: `category` for "
+                          "categorical series, `time` for dates, else `linear`."),
+        linthresh=Setting(number(positive=True),
+                          doc="Half-width of the linear region of a `symlog` axis."),
+        tz=Setting(lambda v: v,
+                   doc="Time zone of a time axis (a `tzinfo`); default: the zone of the "
+                       "first aware date, else naive (UTC)."),
+        limits=Setting(check_limits,
+                       doc="`\"auto\"`, `\"lo/hi\"` (`min`, `max`, numbers, `q:F`) or `(lo, hi)`."),
+        padding=Setting(either(literal("auto"), number(lo=0)),
+                        doc="Space added to automatic limits, as a fraction of the range; "
+                            "`\"auto\"`: `auto_padding`, or 0 on axes of series drawn to "
+                            "exact limits (box value axes, heatmaps, …) and in plots "
+                            "without axes."),
+        auto_padding=Setting(number(lo=0),
+                             doc="The fraction `padding=\"auto\"` adds on each side."),
+        invert=Setting(boolean, doc="Reverse the axis."),
+        ticks=Setting(_ticks_value, doc="`False` (no ticks) or a list of tick values."),
+        tick_labels=Setting(lambda v: [text(x) for x in v], doc="Labels of `ticks`."),
+        minor_ticks=Setting(_minor_value,
+                            doc="`True`, `False` or a list of values; default: on for log10."),
+        tick_format=Setting(check_format,
+                            doc="Number format: `auto`, `percent`, `sci`, `eng`, `si`, `int`, "
+                                "a format string or a function."),
+        tick_rotation=Setting(_rotation,
+                              doc="Label rotation in degrees, or `\"auto\"` (45° when "
+                                  "category labels overlap)."),
+        max_ticks=Setting(either(literal("auto"), number(lo=1, integer=True)),
+                          doc="Most major ticks; `\"auto\"`: one per `tick_spacing` of "
+                              "axis length, at least 2, at most `auto_max_ticks`."),
+        tick_spacing=Setting(pair(number(positive=True)),
+                             doc="Space per automatic tick, in tick label font sizes, on "
+                                 "horizontal and vertical axes."),
+        time_tick_spacing=Setting(pair(number(positive=True)),
+                                  doc="`tick_spacing` of time axes."),
+        auto_max_ticks=Setting(pair(number(lo=2, integer=True)),
+                               doc="Most automatic ticks on numeric and time axes."),
+        sci_limits=Setting(pair(number(integer=True)),
+                           doc="Exponents beyond which labels become mantissas × 10ᵏ."),
+        tick_length=Setting(number(lo=0), doc="Tick length (pt).", length=True),
+        minor_tick_length=Setting(number(lo=0),
+                                  doc="Minor tick length (pt); default 0.6 × `tick_length`.", length=True),
+        tick_direction=Setting(one_of("out", "in", "both"), doc="`out`, `in` or `both`."),
+        tick_width=Setting(number(lo=0), doc="Tick line width (pt).", length=True),
+        tick_size=Setting(number(positive=True),
+                          doc="Font size of tick labels (pt).", length=True),
+        tick_pad=Setting(number(lo=0), doc="Gap between ticks and labels (pt).", length=True),
+        label_pad=Setting(number(lo=0), doc="Gap between tick labels and the label (pt).", length=True),
+        color=Setting(color,
+                      doc="Color of the axis line, ticks and labels (the default of "
+                          "`line_color`, `tick_color`, `tick_label_color`, `label_color`)."),
+        line_color=Setting(color, doc="Axis line color."),
+        tick_color=Setting(color, doc="Tick color."),
+        tick_label_color=Setting(color, doc="Tick label color."),
+        label_color=Setting(color, doc="Axis title color."),
+        label_weight=Setting(one_of("normal", "bold"), doc="Axis title weight."),
+        label_style=Setting(one_of("normal", "italic"), doc="Axis title style."),
+        side=Setting(one_of("left", "right", "bottom", "top"),
+                     doc="Where the ticks, labels and axis line go: `bottom` or `top` (x "
+                         "axis), `left` or `right` (y axis)."),
+        tick_label_weight=Setting(one_of("normal", "bold"),
+                                  doc="Tick label weight."),
+        mirror=Setting(boolean, doc="Ticks also on the opposite side of the axes."),
+        spine_offset=Setting(number(lo=0),
+                             doc="Distance the axis line (with its ticks and labels) is "
+                                 "moved away from the axes (pt).", length=True),
+        spine_trim=Setting(boolean,
+                           doc="Axis line from the first to the last major tick only."),
+        include_zero=Setting(either(boolean, literal("auto")),
+                             doc="Extend automatic limits to 0 (linear and sqrt scales), "
+                                 "before padding and `nice`: `True`, or `\"auto\"` where a "
+                                 "series on the axis asks for it (Vega-Lite's rule: scatter "
+                                 "axes, the value axis of lines, areas and boxes)."),
+        zero_line=Setting(boolean, doc="A line across the plot at 0."),
+        zero_line_color=Setting(color,
+                                doc="Zero line color; default `line_color`."),
+        zero_line_width=Setting(number(lo=0),
+                                doc="Zero line width (pt); default `line_width`.",
+                                length=True),
+        nice=Setting(boolean,
+                     doc="Extend automatic limits to the enclosing major ticks (linear and "
+                         "log scales)."),
+        line_width=Setting(number(lo=0), doc="Axis line width (pt).", length=True),
+        grid=Setting(boolean, doc="Major grid lines across the plot."),
+        grid_color=Setting(color, doc="Grid line color."),
+        grid_width=Setting(number(lo=0), doc="Grid line width (pt).", length=True),
+        grid_style=Setting(_dash, doc="Grid line style or dash list."),
+        minor_grid=Setting(boolean,
+                           doc="Minor grid lines: at the minor ticks, or halfway between "
+                               "major ticks on linear axes without minor ticks."),
+        minor_grid_color=Setting(color,
+                                 doc="Minor grid color; default `grid_color`."),
+        minor_grid_width=Setting(number(lo=0),
+                                 doc="Minor grid width (pt); default half `grid_width`.",
+                                 length=True),
+        minor_grid_style=Setting(_dash,
+                                 doc="Minor grid style; default `grid_style`."),
+        visible=Setting(boolean, doc="Draw the axis (ticks, labels)."),
+        font_size=Setting(number(positive=True), inherited=True, doc="Base font size (pt).", length=True),
+        font_family=Setting(str, inherited=True, doc="Font family."),
+        text_color=Setting(color, inherited=True, doc="Text color."),
+        **number_settings(),
+    )
+
+    def __init__(self, owner: Any, role: str) -> None:
+        self._owner = owner
+        self.role = role
+        super().__init__()
+
+    def _parent(self) -> Settings | None:
+        return self._owner
+
+    def _theme_keys(self, name: str) -> tuple[str, ...]:
+        from .colorbar import Colorbar
+        if isinstance(self._owner, Colorbar):
+            if name in Colorbar.SETTINGS:
+                return (f"Axis.{name}",)
+            return (f"Colorbar.{name}", f"Axis.{name}")
+        return (f"{self.role.upper()}Axis.{name}", f"Axis.{name}")
+
+    def __call__(self, label: Any = None, **settings: Any) -> "Axis":
+        if label is not None:
+            settings["label"] = label
+        return self.set(**settings)
+
+    def __repr__(self) -> str:
+        return f"Axis({self.role})"
+
+
+class Mapper:
+    """Data → page coordinate on one axis: ``page = a·f(v) + b``."""
+
+    __slots__ = ("function", "a", "b", "forward", "options")
+
+    def __init__(self, scale: Scale | None, flo: float, fhi: float, p0: float, p1: float) -> None:
+        self.function = scale.function if scale is not None else None
+        self.options = scale.options if scale is not None else {}
+        self.forward = scale.f if scale is not None else (lambda v: v)
+        span = fhi - flo
+        self.a = (p1 - p0) / span if span else 0.0
+        self.b = p0 - self.a * flo
+
+    def __call__(self, v: float) -> float:
+        return self.a * self.forward(v) + self.b
+
+    def many(self, values: Any) -> Any:
+        return _backend.scaled(values, self.a, self.b, self.function, **self.options)
+
+    def position(self, f: float) -> float:
+        """Page coordinate of a value already through the scale function."""
+        return self.a * f + self.b
+
+
+class AxisState:
+    """An axis while drawing: resolved scale, limits, categories and ticks."""
+
+    def __init__(self, axis: Axis) -> None:
+        self.axis = axis
+        self.scale: Scale | None = None      # None: category
+        self.categories: list[Any] = []
+        self.lo = 0.0                        # data limits (category: index range)
+        self.hi = 1.0
+        self.flo = 0.0                       # limits after the scale function
+        self.fhi = 1.0
+        self.data_lo = math.nan              # union of the series' extents
+        self.data_hi = math.nan
+        self.ticks: list[Tick] = []
+        self.factor = 0                      # ×10^factor written at the axis end
+        self.rotation = 0.0
+        self.length = 0.0
+        self.auto_invert = False             # inverted by a series (heatmap rows)
+        self.bare = False                    # category axis of heatmaps only: labels only
+        self._auto = (False, False)          # automatic low / high limit (for `nice`)
+        self._zero_pad = False               # a series wants exact limits (heatmaps)
+        self._base = (0.0, 1.0, 0.0, 1.0)    # lo, hi, flo, fhi before `nice`
+        self.shared: "AxisState | None" = None   # the group's leader (shared axes)
+        self.hide_labels = False             # an inner plot of a shared group
+        self.auto_label: Any = None          # the column name of the series' data
+        self.tz: Any = None                  # time zone of a time axis
+        self.offset: str | None = None       # larger date unit common to the time ticks
+
+    def on_far_side(self) -> bool:
+        """Whether the axis is drawn on the top (x) or right (y) side of the axes."""
+        return self.axis.get("side") in ("top", "right")
+
+    @property
+    def is_category(self) -> bool:
+        return self.scale is None
+
+    def f(self, v: float) -> float:
+        return self.scale.f(v) if self.scale is not None else v
+
+    @property
+    def inverted(self) -> bool:
+        if self.shared is not None:
+            return self.shared.inverted
+        a = self.axis
+        return a.get("invert") if a.is_set("invert") else self.auto_invert
+
+    def tick_out(self) -> tuple[float, float]:
+        """Tick extent outside and inside the axes."""
+        a = self.axis
+        if self.bare and not a.is_set("tick_length"):
+            return 0.0, 0.0
+        n = a.get("tick_length")
+        d = a.get("tick_direction")
+        return (n if d in ("out", "both") else 0.0), (n if d in ("in", "both") else 0.0)
+
+    def mapper(self, p0: float, p1: float) -> Mapper:
+        inv = self.inverted
+        if inv:
+            p0, p1 = p1, p0
+        return Mapper(self.scale, self.flo, self.fhi, p0, p1)
+
+    # -- limits ------------------------------------------------------------------
+
+    def resolve(self, series: Sequence[Any], padded: bool) -> None:
+        """Scale, categories and limits from the series drawn on this axis."""
+        role = self.axis.role
+        scale_name = self.axis.get("scale")
+        cats: list[Any] = []
+        categorical = False
+        for s in series:
+            c = s.categories(role)
+            if c is not None:
+                categorical = True
+                for k in c:
+                    if k not in cats:
+                        cats.append(k)
+        on_axis = [s for s in series if s.has_axis(role)]
+        self.auto_invert = any(s.inverts(role) for s in on_axis)
+        times = [s for s in on_axis if getattr(s, "time_role", lambda r: None)(role)]
+        if scale_name is None:
+            scale_name = "category" if categorical else ("time" if times else "linear")
+        self.tz = self.axis.get("tz")
+        if self.tz is None and times:
+            self.tz = times[0].time_role(role)[1]
+        from .series.heatmap import Heatmap
+        self.bare = (scale_name == "category" and bool(on_axis)
+                     and all(isinstance(s, Heatmap) for s in on_axis))
+        if scale_name == "category":
+            if any(s.categories(role) is None and s.has_axis(role) for s in series):
+                raise ValueError(f"{role} axis mixes categorical and numeric series")
+            self.scale = None
+            self.categories = cats
+            n = max(len(cats), 1)
+            self.lo, self.hi = -0.5, n - 0.5
+            spec = self.axis.get("limits")
+            if spec != "auto":
+                lo, hi, _, _ = resolve_limits(spec, self.lo, self.hi)
+                self.lo, self.hi = float(lo), float(hi)
+            self.flo, self.fhi = self.lo, self.hi
+            return
+        if categorical:
+            raise ValueError(f"{role} axis has categorical series but scale {scale_name!r}")
+        scale = self.scale = get_scale(scale_name, self.axis.get("linthresh"))
+        count, lo, hi = 0, math.inf, -math.inf
+        zero_pad = False
+        for s in series:
+            if not s.has_axis(role):
+                continue
+            n, a, b = s.extent(role, scale)
+            if n:
+                count += n
+                lo, hi = min(lo, a), max(hi, b)
+            zero_pad = zero_pad or s.zero_padding(role)
+        if not count:
+            lo, hi = (1.0, 10.0) if scale.name.startswith("log") else (0.0, 1.0)
+        self.data_lo, self.data_hi = lo, hi
+        zero = self.axis.get("include_zero")
+        if zero == "auto":
+            zero = any(s.zero_default(role) for s in on_axis)
+        if zero and scale.name in ("linear", "sqrt"):
+            lo, hi = min(lo, 0.0), max(hi, 0.0)
+        spec = self.axis.get("limits")
+        qs = needs_quantiles(spec)
+        qmap: dict[float, float] = {}
+        if qs:
+            from array import array
+            vals = array("d")
+            for s in series:
+                if s.has_axis(role):
+                    v = s.values(role)
+                    if v is not None:
+                        vals.extend(_backend.doubles(v))
+            if scale.function is not None:
+                vals = array("d", [v for v in vals if scale.contains(v)])
+            for q, r in zip(qs, _backend.quantiles(vals, qs)):
+                qmap[q] = r
+        lo2, hi2, lo_auto, hi_auto = resolve_limits(spec, lo, hi, lambda q: qmap[q])
+        flo, fhi = scale.f(lo2), scale.f(hi2)
+        if not (math.isfinite(flo) and math.isfinite(fhi)):
+            raise ValueError(f"{role} axis limits {lo2!r}/{hi2!r} are outside the "
+                             f"{scale.name} scale's domain")
+        if flo > fhi:
+            flo, fhi = fhi, flo
+            lo_auto, hi_auto = hi_auto, lo_auto
+        if fhi == flo:
+            flo, fhi = flo - 0.5, fhi + 0.5
+            if scale.name == "sqrt" and flo < 0:
+                flo, fhi = 0.0, fhi + 0.5
+        else:
+            pad = self.axis.get("padding")
+            if pad == "auto":
+                pad = self.axis.get("auto_padding") if padded and not zero_pad else 0.0
+            d = (fhi - flo) * pad
+            if lo_auto:
+                flo -= d
+                if scale.name == "sqrt" and flo < 0:
+                    flo = 0.0
+            if hi_auto:
+                fhi += d
+            if not math.isfinite(scale.inverse(flo)):
+                flo = scale.f(lo2) if scale.f(lo2) < fhi else flo + d
+            if not math.isfinite(scale.inverse(fhi)):
+                fhi = scale.f(hi2)
+        self.flo, self.fhi = flo, fhi
+        self.lo, self.hi = scale.inverse(flo), scale.inverse(fhi)
+        self._auto = (lo_auto, hi_auto)
+        self._zero_pad = zero_pad
+        self._base = (self.lo, self.hi, self.flo, self.fhi)
+
+    def copy_limits(self, other: "AxisState") -> None:
+        """Take the scale, categories and limits of ``other`` (a shared group's leader)."""
+        for k in ("scale", "categories", "lo", "hi", "flo", "fhi", "data_lo", "data_hi",
+                  "auto_invert", "bare", "_auto", "_zero_pad", "_base"):
+            setattr(self, k, getattr(other, k))
+        self.categories = list(other.categories)
+
+    # -- ticks -------------------------------------------------------------------
+
+    def tick_font(self) -> Font:
+        a = self.axis
+        return Font(a.get("tick_size"), a.get("font_family"), a.get("tick_label_weight"),
+                    color=a.get("tick_label_color"))
+
+    def label_font(self) -> Font:
+        a = self.axis
+        return Font(a.get("label_size"), a.get("font_family"), a.get("label_weight"),
+                    a.get("label_style"), color=a.get("label_color"))
+
+    def compute_ticks(self, canvas: Any, length: float, horizontal: bool) -> None:
+        """Ticks for an axis ``length`` points long (``horizontal``: labels side by side);
+        with ``nice``, automatic limits are then extended to the enclosing major ticks."""
+        lead = self.shared
+        if lead is not None:
+            self.copy_limits(lead)
+            if lead.length and abs(lead.length - length) <= 0.5:
+                self.lo, self.hi, self.flo, self.fhi = lead.lo, lead.hi, lead.flo, lead.fhi
+                self.ticks, self.factor = list(lead.ticks), lead.factor
+                self.rotation, self.length = lead.rotation, length
+                return
+        nice = (self.scale is not None and self.axis.get("nice") and any(self._auto)
+                and not self._zero_pad
+                and (self.scale.name == "linear" or self.scale.name.startswith("log")))
+        if nice:
+            self.lo, self.hi, self.flo, self.fhi = self._base
+        self._compute_ticks(canvas, length, horizontal)
+        if not nice:
+            return
+        assert self.scale is not None
+        majors = sorted(self.major_positions())
+        if self.scale.name == "linear":
+            if len(majors) < 2:
+                return
+            step = majors[1] - majors[0]
+        else:
+            step = 1.0
+        flo, fhi = self.flo, self.fhi
+        eps = step * 1e-9
+        if self._auto[0]:
+            flo = math.floor((flo + eps) / step) * step
+        if self._auto[1]:
+            fhi = math.ceil((fhi - eps) / step) * step
+        if (flo, fhi) != (self.flo, self.fhi) and math.isfinite(self.scale.inverse(flo)) \
+                and math.isfinite(self.scale.inverse(fhi)):
+            self.flo, self.fhi = flo, fhi
+            self.lo, self.hi = self.scale.inverse(flo), self.scale.inverse(fhi)
+            self._compute_ticks(canvas, length, horizontal)
+
+    def minor_grid_positions(self) -> list[float]:
+        """Values of the minor grid lines: the minor ticks, else (linear axes) halfway
+        between major ticks."""
+        minors = [t.value for t in self.ticks if not t.major]
+        if minors or self.scale is None or self.scale.name != "linear":
+            return minors
+        majors = sorted(t.value for t in self.ticks if t.major)
+        if len(majors) < 2:
+            return []
+        step = majors[1] - majors[0]
+        lo, hi = min(self.lo, self.hi), max(self.lo, self.hi)
+        out = [m + step / 2 for m in [majors[0] - step] + majors]
+        return [v for v in out if lo <= v <= hi]
+
+
+    def _max_ticks(self, length: float, horizontal: bool, font_size: float,
+                   time: bool = False) -> int:
+        """``max_ticks``, or the automatic count for an axis of ``length`` pt."""
+        a = self.axis
+        most = a.get("max_ticks")
+        if most != "auto":
+            return int(most)
+        spacing = a.get("time_tick_spacing" if time else "tick_spacing")[0 if horizontal else 1]
+        cap = a.get("auto_max_ticks")[1 if time else 0]
+        return min(cap, max(2, int(length / (spacing * font_size)) + 1))
+    def _compute_ticks(self, canvas: Any, length: float, horizontal: bool) -> None:
+        a = self.axis
+        self.length = length
+        self.factor = 0
+        self.rotation = 0.0
+        given = a.get("ticks")
+        font = self.tick_font()
+        if given is False:
+            self.ticks = []
+            return
+        if self.is_category:
+            self._category_ticks(canvas, length, horizontal, font)
+            return
+        assert self.scale is not None
+        self.offset = None
+        if self.scale.name == "time" and given is None:
+            from .times import time_ticks
+            most = self._max_ticks(length, horizontal, font.size, time=True)
+            fmt = a.get("tick_format")
+            pairs, self.offset = time_ticks(self.lo, self.hi, most, self.tz,
+                                            fmt if fmt != "auto" else "auto")
+            self.ticks = [Tick(v, lab) for v, lab in pairs]
+            rot = a.get("tick_rotation")
+            self.rotation = 0.0 if rot == "auto" else float(rot)
+            return
+        fmt = a.get("tick_format")
+        style = NumberStyle.of(a)
+        if given is not None:
+            labels = a.get("tick_labels")
+            values = [float(v) for v in given]
+            if labels is None:
+                labels, self.factor = format_axis(values, fmt, style, a.get("sci_limits"))
+            self.ticks = [Tick(v, s) for v, s in zip(values, labels)]
+        else:
+            fs = font.size
+            max_ticks = self._max_ticks(length, horizontal, fs)
+
+            def fits(values: list[float], step: float) -> bool:
+                if not horizontal or len(values) < 2:
+                    return True
+                labels, _ = format_axis(values, fmt, style, a.get("sci_limits"))
+                widest = max(box(canvas, s, font)[0] for s in labels)
+                span = self.fhi - self.flo
+                if not span:
+                    return True
+                gap = length * abs(self.f(values[1]) - self.f(values[0])) / span
+                return widest + 0.6 * fs <= gap
+
+            minor = a.get("minor_ticks")
+            self.ticks, self.factor = numeric_ticks(
+                self.scale, self.lo, self.hi, max_ticks, fmt, style, a.get("sci_limits"),
+                minor=minor is not False, length=length,
+                fits=fits if self.scale.name == "linear" else None)
+            if minor is True and self.scale.name == "linear":
+                majors = [t.value for t in self.ticks if t.major]
+                if len(majors) >= 2:
+                    step = majors[1] - majors[0]
+                    have = set(majors)
+                    self.ticks += [Tick(v, None, False) for v in minor_linear(self.lo, self.hi, step)
+                                   if not any(abs(v - m) < step * 1e-6 for m in have)]
+        minors = a.get("minor_ticks")
+        if isinstance(minors, list):
+            self.ticks += [Tick(v, None, False) for v in minors]
+        lo, hi = min(self.flo, self.fhi), max(self.flo, self.fhi)
+        eps = (hi - lo) * 1e-9
+        self.ticks = [t for t in self.ticks
+                      if lo - eps <= self.f(t.value) <= hi + eps]
+        rot = a.get("tick_rotation")
+        self.rotation = 0.0 if rot == "auto" else float(rot)
+
+    def _category_ticks(self, canvas: Any, length: float, horizontal: bool, font: Font) -> None:
+        a = self.axis
+        cats = self.categories
+        labels = a.get("tick_labels") or [str(c) if not isinstance(c, (list, str)) else c
+                                           for c in cats]
+        fmt = a.get("tick_format")
+        if fmt != "auto" and not a.get("tick_labels"):
+            if all(isinstance(c, (int, float)) and not isinstance(c, bool) for c in cats):
+                labels = format_axis([float(c) for c in cats], fmt, NumberStyle.of(a), None)[0]
+            elif callable(fmt):
+                labels = [fmt(c) for c in cats]
+            elif fmt not in ("percent", "sci", "eng", "si", "int"):
+                labels = [fmt.format(c) for c in cats]
+        ticks = [Tick(float(i), lab) for i, lab in enumerate(labels)]
+        span = abs(self.fhi - self.flo) or 1.0
+        step = length / span            # points per category
+        rot = a.get("tick_rotation")
+        fs = font.size
+        if not ticks:
+            self.ticks = []
+            return
+        if horizontal:
+            widest = max(box(canvas, lab, font)[0] for lab in labels)
+            if rot == "auto":
+                rot = 45.0 if widest + 0.5 * fs > step else 0.0
+            need = (widest + 0.5 * fs) if rot == 0 else 1.6 * fs
+        else:
+            rot = 0.0 if rot == "auto" else rot
+            need = 1.3 * fs
+        self.rotation = float(rot)
+        every = max(1, math.ceil(need / step)) if step > 0 else 1
+        if every > 1:
+            ticks = [t for i, t in enumerate(ticks) if i % every == 0]
+        self.ticks = ticks
+
+    def major_positions(self) -> list[float]:
+        return [self.f(t.value) for t in self.ticks if t.major]