"""A small, dependency-free smooth-spline line chart (QWidget). Given a series of ``(label, value)`` points it draws a Catmull-Rom spline with a soft area fill, a highlighted endpoint, y-grid + value labels, and a few x-axis labels — theme-aware (light/dark). Used by the Dashboard's token/cost-over-time chart; kept generic so any screen can reuse it. """ from __future__ import annotations from typing import Callable, List, Optional, Tuple from PySide6.QtCore import QPointF, Qt from PySide6.QtGui import QBrush, QColor, QLinearGradient, QPainter, QPainterPath, QPen from PySide6.QtWidgets import QWidget from ..theme import current_palette def _endpoint_label_rect(point_x: float, point_y: float, text_width: float, widget_width: float, top: float) -> Tuple[float, float]: """Top-left (x, y) for the endpoint value label's bounding box, given its ACTUAL text width (not a hardcoded guess — that used to clip/hide longer formatted amounts, since ``QPainter.drawText(rect, ...)`` clips to the rect it's given). Clamped so the box never runs off either horizontal edge; flips BELOW the point instead of above when the point sits too close to the title to avoid overlapping it.""" box_w = text_width + 6 x = max(2, min(point_x - box_w, widget_width - 2 - box_w)) y = point_y - 22 if y < top + 2: # too close to the title — flip below the dot y = point_y + 8 return x, y def _catmull_rom(points: List[QPointF]) -> QPainterPath: """A smooth spline through ``points`` (Catmull-Rom → cubic Bézier).""" path = QPainterPath() if not points: return path path.moveTo(points[0]) if len(points) == 1: return path n = len(points) for i in range(n - 1): p0 = points[i - 1] if i > 0 else points[i] p1 = points[i] p2 = points[i + 1] p3 = points[i + 2] if i + 2 < n else points[i + 1] c1 = QPointF(p1.x() + (p2.x() - p0.x()) / 6.0, p1.y() + (p2.y() - p0.y()) / 6.0) c2 = QPointF(p2.x() - (p3.x() - p1.x()) / 6.0, p2.y() - (p3.y() - p1.y()) / 6.0) path.cubicTo(c1, c2, p2) return path class SplineChart(QWidget): def __init__(self): super().__init__() self._points: List[Tuple[str, float]] = [] self._fmt: Callable[[float], str] = lambda v: f"{v:.2f}" self._title = "" self._refs: List[Tuple[float, str, str]] = [] # (value, label, color hex) self.setMinimumHeight(200) def set_data(self, points: List[Tuple[str, float]], value_fmt: Optional[Callable[[float], str]] = None, title: str = "") -> None: self._points = list(points or []) if value_fmt is not None: self._fmt = value_fmt self._title = title self.update() def set_reference_lines(self, refs: List[Tuple[float, str, str]]) -> None: """Dashed horizontal comparison lines: ``[(value, label, color_hex), …]`` (e.g. last week / last month with a % delta). Included in the y-scale.""" self._refs = list(refs or []) self.update() def paintEvent(self, _e): # noqa: N802 p = QPainter(self) p.setRenderHint(QPainter.Antialiasing) tok = current_palette() grid = QColor(tok.chart_grid) text = QColor(tok.chart_label) accent = QColor(tok.accent) w, h = self.width(), self.height() pts = self._points if len(pts) < 1: p.setPen(text) p.drawText(self.rect(), Qt.AlignCenter, "—") return vals = [v for _l, v in pts] scale_vals = vals + [r[0] for r in self._refs] # refs must fit on-scale too vmax = max(scale_vals) or 1.0 vmin = min(min(scale_vals), 0.0) span = (vmax - vmin) or 1.0 # The left margin fits the y-axis grid labels' ACTUAL widest rendering # — a fixed 54px used to clip (hide) longer formatted amounts, since # QPainter.drawText(rect, ...) clips to the rect it's given. grid_labels = [self._fmt(vmax - span * i / 4) for i in range(5)] label_w = max((p.fontMetrics().horizontalAdvance(s) for s in grid_labels), default=0) left, right, top, bottom = max(54, label_w + 10), 14, 24, 26 self._last_left = left # exposed for tests — the margin actually used plot_w = max(1, w - left - right) plot_h = max(1, h - top - bottom) if self._title: p.setPen(text) f = p.font(); f.setBold(True); p.setFont(f) p.drawText(left, 4, plot_w, 18, Qt.AlignLeft | Qt.AlignVCenter, self._title) f.setBold(False); p.setFont(f) # y grid + labels (4 lines) p.setPen(QPen(grid, 1)) for i in range(5): y = top + plot_h * i / 4 p.drawLine(left, int(y), left + plot_w, int(y)) p.setPen(text) p.drawText(0, int(y) - 8, left - 6, 16, Qt.AlignRight | Qt.AlignVCenter, grid_labels[i]) p.setPen(QPen(grid, 1)) # dashed comparison lines (last week / last month) — drawn under the # spline so the curve stays readable; label sits at the left. for value, label, color in self._refs: y = top + plot_h * (1 - (value - vmin) / span) c = QColor(color) p.setPen(QPen(c, 1, Qt.DashLine)) p.drawLine(left, int(y), left + plot_w, int(y)) if label: p.setPen(c) p.drawText(left + 4, int(y) - 15, plot_w - 8, 14, Qt.AlignLeft | Qt.AlignVCenter, label) n = len(pts) xs = [left + (plot_w * i / (n - 1) if n > 1 else plot_w / 2) for i in range(n)] screen = [QPointF(xs[i], top + plot_h * (1 - (vals[i] - vmin) / span)) for i in range(n)] spline = _catmull_rom(screen) # area fill under the curve area = QPainterPath(spline) area.lineTo(screen[-1].x(), top + plot_h) area.lineTo(screen[0].x(), top + plot_h) area.closeSubpath() grad = QLinearGradient(0, top, 0, top + plot_h) c0 = QColor(accent); c0.setAlpha(80) c1 = QColor(accent); c1.setAlpha(10) grad.setColorAt(0, c0); grad.setColorAt(1, c1) p.fillPath(area, QBrush(grad)) # the spline line p.setPen(QPen(accent, 2)) p.drawPath(spline) # endpoint dot + latest value p.setBrush(QBrush(accent)); p.setPen(Qt.NoPen) p.drawEllipse(screen[-1], 4, 4) p.setPen(accent) f = p.font(); f.setBold(True); p.setFont(f) # QPainter.drawText(rect, ...) CLIPS to the given rect — a hardcoded # 60px box used to silently cut off (hide) longer formatted amounts # (currency symbol + thousands separators easily exceed 60px). label = self._fmt(vals[-1]) tw = p.fontMetrics().horizontalAdvance(label) label_x, label_y = _endpoint_label_rect(screen[-1].x(), screen[-1].y(), tw, w, top) p.drawText(int(label_x), int(label_y), int(tw + 6), 16, Qt.AlignRight | Qt.AlignVCenter, label) f.setBold(False); p.setFont(f) # x labels: first, middle, last p.setPen(text) idxs = sorted(set([0, n // 2, n - 1])) for i in idxs: p.drawText(int(xs[i]) - 40, h - bottom + 4, 80, 18, Qt.AlignCenter, pts[i][0])