dataface 0.1.2__py3-none-any.whl

dataface/core/render/chart/tick_values.py

@@ -0,0 +1,66 @@
+"""Compute axis tick values and stacked-bar domain totals."""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+
+def nice_tick_values(
+    domain_min: float,
+    domain_max: float,
+    target_count: int,
+) -> list[float]:
+    """Return ≤ target_count tick values at a "nice" step (1, 2, 5 × 10^k).
+
+    Mirrors d3-scale's tick algorithm but enforces ≤ N rather than ≈ N.
+    tick_count = intervals + 1, where intervals = ceil(span / step).
+    We pick the smallest nice step where (intervals + 1) ≤ target_count.
+
+    Examples:
+        nice_tick_values(0, 4000, 6) → [0, 1000, 2000, 3000, 4000]  (5 ticks)
+        nice_tick_values(0, 1400, 5) → [0, 500, 1000, 1500]          (4 ticks)
+        nice_tick_values(0, 60, 6)   → [0, 20, 40, 60]               (4 ticks)
+    """
+    if domain_min == domain_max or target_count < 1:
+        return [domain_min]
+
+    span = domain_max - domain_min
+    # raw_step targets (target_count - 1) intervals so ticks fit within N.
+    raw_step = span / (target_count - 1) if target_count > 1 else span
+
+    # Pick the smallest "nice" step from {1, 2, 5} × 10^k where ticks ≤ N.
+    # ticks = floor(span / step) + 1 (start tick + one per interval, aligned).
+    exp = math.floor(math.log10(raw_step)) if raw_step > 0 else 0
+    magnitude = 10.0**exp
+    nice_steps = [magnitude, 2 * magnitude, 5 * magnitude, 10 * magnitude]
+    step = next(
+        (s for s in nice_steps if math.ceil(span / s) + 1 <= target_count),
+        nice_steps[-1],
+    )
+
+    start = math.floor(domain_min / step) * step
+    end = math.ceil(domain_max / step) * step
+    n = round((end - start) / step)
+    return [round(start + i * step, 10) for i in range(n + 1)]
+
+
+def stacked_bar_totals_max(
+    data: list[dict[str, Any]],
+    x_field: str,
+    y_field: str,
+) -> float | None:
+    """Return the max per-category positive stacked total, or None if no valid rows.
+
+    Sums only positive y values per category, matching VL's behaviour of stacking
+    positives upward and negatives downward independently.  Caller must guard
+    against stack_mode "normalize" (domain is always [0, 1] there).
+    """
+    totals: dict[object, float] = {}
+    for row in data:
+        x = row.get(x_field)
+        y = row.get(y_field)
+        if x is None or y is None:
+            continue
+        totals[x] = totals.get(x, 0.0) + max(0.0, float(y))
+    return max(totals.values()) if totals else None