CI deploy local

src/runtime.py

@@ -157,14 +157,55 @@ class ForecastRun:
 
 
 def future_timestamps(context: pd.DataFrame, horizon: int) -> pd.DatetimeIndex:
-    """Continue the context's own cadence forward by `horizon` bars."""
+    """The next `horizon` bars this market will actually print.
+
+    Not `last + step * i`. That is clock time, and only a market that never
+    closes prints on clock time. Extrapolating it for equities put three
+    quarters of every hourly forecast on hours the exchange is shut: those
+    bars never appear, so those steps never resolve, and the equity standings
+    were quietly computed from whichever steps happened to land before the
+    close -- a shorter effective horizon than crypto was being judged on.
+
+    The trading calendar is read from the series itself rather than hardcoded
+    or imported: whichever (weekday, hour, minute) slots this asset has
+    actually printed in are the ones it will print in next. A 24/7 market
+    occupies every slot, so this collapses to plain extrapolation for crypto.
+    """
     ts = pd.to_datetime(context["ts"], utc=True)
-    deltas = ts.diff().dropna()
-    if not len(deltas):
+    if len(ts) < 2:
         raise AdapterError("cannot infer cadence from a single bar")
+
+    deltas = ts.diff().dropna()
     modal = deltas.mode()
     step = modal.iloc[0] if len(modal) else deltas.median()
     last = ts.iloc[-1]
+
+    # Daily bars are keyed on weekday alone. Their UTC hour shifts with
+    # daylight saving, so keying on the hour too fragments the calendar into
+    # "Wednesdays in summer" and drops most of the week.
+    daily = step >= pd.Timedelta("1D")
+    if daily:
+        slots = {t.weekday() for t in ts}
+        key = lambda t: t.weekday()                       # noqa: E731
+    else:
+        slots = {(t.weekday(), t.hour, t.minute) for t in ts}
+        key = lambda t: (t.weekday(), t.hour, t.minute)   # noqa: E731
+    if not slots:                      # pragma: no cover - guarded by len check
+        return pd.DatetimeIndex([last + step * (i + 1) for i in range(horizon)])
+
+    out: list[pd.Timestamp] = []
+    cursor = last
+    # Bounded: a market open one hour a week still resolves inside this, and a
+    # pathological slot set falls through to extrapolation rather than hanging.
+    for _ in range(horizon * 64):
+        cursor = cursor + step
+        if key(cursor) in slots:
+            out.append(cursor)
+            if len(out) == horizon:
+                return pd.DatetimeIndex(out)
+
+    log.warning("could not walk %d bars forward from %s; extrapolating",
+                horizon, last)
     return pd.DatetimeIndex([last + step * (i + 1) for i in range(horizon)])
 
 

src/ui/chart.py

@@ -165,7 +165,9 @@ def build(history: pd.DataFrame, runs: list, asset: str, horizon: int,
     return {
         "svg": "".join(parts),
         "grid": grid,
-        "time_labels": _time_labels(ts, scale, n, horizon),
+        "time_labels": _time_labels(
+            ts, scale, n, horizon,
+            future=getattr(runs[0], "target_ts", None) if runs else None),
         "now_left": f"{now_x / VIEW_W * 100:.2f}%",
         # The line marks where the forecast begins. On a live forecast that is
         # now; on an archived one it is when it was issued, and calling it
@@ -353,19 +355,54 @@ def _volumes(hist: pd.DataFrame, runs: list, scale: Scale, n: int,
     return "".join(out)
 
 
-def _time_labels(ts: pd.Series, scale: Scale, n: int, horizon: int) -> list[dict]:
+def _time_labels(ts: pd.Series, scale: Scale, n: int, horizon: int,
+                 future: pd.DatetimeIndex | None = None) -> list[dict]:
+    """Axis labels, read off the actual bars rather than extrapolated.
+
+    These used to be computed as `last + modal_step * offset`, which is only
+    right when bars are evenly spaced. Crypto trades around the clock so it
+    looked fine; equities do not. Fifty-six hourly SPY bars span about ten
+    calendar days, not fifty-six hours, so every history label was wrong --
+    one read "12 09:30" against a bar that was actually "04 17:30", eight days
+    out, with no way to tell from the chart.
+
+    So the history side is indexed straight into the timestamps being drawn,
+    and the forecast side into the forecast's own target timestamps.
+    """
     if len(ts) < 2:
         return []
-    step = ts.diff().dropna().mode()
-    step = step.iloc[0] if len(step) else pd.Timedelta("1h")
-    last = ts.iloc[-1]
+
+    deltas = ts.diff().dropna()
+    modal = deltas.mode()
+    step = modal.iloc[0] if len(modal) else pd.Timedelta("1h")
+    # A daily series prints midnight on every bar, so the clock is noise and
+    # the month is what is missing.
+    fmt = "%d %b" if step >= pd.Timedelta("1D") else "%d %H:%M"
+
     out = []
     for i in range(6):
         idx = round((scale.slots - 1) * i / 5)
-        when = last + step * (idx - (n - 1))
+        when = _stamp_at(idx, ts, n, future, step)
+        if when is None:
+            continue
         x = scale.x(idx)
         out.append({
             "left": f"{min(97.0, max(3.0, x / VIEW_W * 100)):.2f}%",
-            "label": when.strftime("%d %H:%M"),
+            "label": when.strftime(fmt),
         })
     return out
+
+
+def _stamp_at(idx: int, ts: pd.Series, n: int,
+              future: pd.DatetimeIndex | None, step) -> pd.Timestamp | None:
+    """The timestamp actually plotted at slot `idx`."""
+    if idx < n:
+        return pd.Timestamp(ts.iloc[idx])
+    ahead = idx - n
+    if future is not None and ahead < len(future):
+        return pd.Timestamp(future[ahead])
+    # Only reached when the drawn horizon outruns the forecast's own targets,
+    # which the caller should not do; extrapolating is the honest fallback.
+    return pd.Timestamp(ts.iloc[-1]) + step * (ahead + 1)
+
+

tests/test_calendar.py

@@ -0,0 +1,164 @@
+"""Forecast targets and axis labels must follow the market, not the clock.
+
+Both used to be computed as `last + modal_step * i`, which is only correct for
+a market that never closes. Crypto trades around the clock, so it looked right
+everywhere it was checked. Equities do not:
+
+* **Axis labels** were wrong by days. A SPY bar at 04 17:30 was labelled
+  12 09:30 -- and nothing on the chart could reveal it.
+* **Forecast targets** landed on hours the exchange was shut. Only 25% of
+  hourly equity steps could ever resolve, so the equity standings were
+  computed from whichever steps happened to fall before the close.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from src import runtime
+from src.ui import chart
+
+
+def _sessions(days: int = 60, hours=range(14, 21)) -> pd.DataFrame:
+    """Hourly bars that trade weekday afternoons and are shut otherwise."""
+    stamps = []
+    day = pd.Timestamp("2026-01-05", tz="UTC")      # a Monday
+    for _ in range(days):
+        if day.weekday() < 5:
+            stamps += [day + pd.Timedelta(hours=h) for h in hours]
+        day += pd.Timedelta(days=1)
+    ts = pd.DatetimeIndex(stamps)
+    close = 600 * np.exp(np.cumsum(np.random.default_rng(3).normal(0, 0.004, len(ts))))
+    return pd.DataFrame({"ts": ts, "open": close, "high": close * 1.002,
+                         "low": close * 0.998, "close": close, "volume": 1000.0})
+
+
+def _daily(days: int = 200) -> pd.DataFrame:
+    """Daily bars on weekdays only."""
+    stamps = [d for d in pd.date_range("2026-01-05", periods=days, tz="UTC")
+              if d.weekday() < 5]
+    ts = pd.DatetimeIndex(stamps)
+    close = 600 * np.exp(np.cumsum(np.random.default_rng(4).normal(0, 0.01, len(ts))))
+    return pd.DataFrame({"ts": ts, "open": close, "high": close * 1.01,
+                         "low": close * 0.99, "close": close, "volume": 1000.0})
+
+
+def _crypto(n: int = 400) -> pd.DataFrame:
+    ts = pd.date_range("2026-01-05", periods=n, freq="1h", tz="UTC")
+    close = 60000 * np.exp(np.cumsum(np.random.default_rng(5).normal(0, 0.004, n)))
+    return pd.DataFrame({"ts": ts, "open": close, "high": close * 1.002,
+                         "low": close * 0.998, "close": close, "volume": 1000.0})
+
+
+# --------------------------------------------------------------------------
+# Forecast targets
+# --------------------------------------------------------------------------
+
+
+def test_intraday_targets_stay_inside_trading_hours():
+    bars = _sessions()
+    future = runtime.future_timestamps(bars, 24)
+
+    assert len(future) == 24
+    for t in future:
+        assert t.weekday() < 5, f"{t} is a weekend"
+        assert 14 <= t.hour <= 20, f"{t} is outside the session"
+
+
+def test_intraday_targets_never_repeat_or_go_backwards():
+    future = runtime.future_timestamps(_sessions(), 24)
+    assert list(future) == sorted(set(future)), "targets repeat or are unordered"
+    assert future[0] > pd.Timestamp("2026-01-05", tz="UTC")
+
+
+def test_daily_targets_skip_weekends():
+    future = runtime.future_timestamps(_daily(), 30)
+    assert len(future) == 30
+    assert all(t.weekday() < 5 for t in future), "a weekend was forecast"
+
+
+def test_a_market_that_never_closes_is_unchanged():
+    """Crypto occupies every slot, so this must collapse to plain extrapolation."""
+    bars = _crypto()
+    future = runtime.future_timestamps(bars, 24)
+    last = pd.to_datetime(bars["ts"], utc=True).iloc[-1]
+    expected = [last + pd.Timedelta(hours=i + 1) for i in range(24)]
+    assert list(future) == expected
+
+
+def test_targets_continue_from_the_last_bar_not_from_now():
+    bars = _sessions()
+    last = pd.to_datetime(bars["ts"], utc=True).iloc[-1]
+    future = runtime.future_timestamps(bars, 6)
+    assert future[0] > last
+    assert (future[0] - last) <= pd.Timedelta("4D"), "skipped more than a weekend"
+
+
+def test_a_single_bar_cannot_produce_a_horizon():
+    from src.adapters import AdapterError
+
+    one = _crypto(1)
+    with pytest.raises(AdapterError):
+        runtime.future_timestamps(one, 4)
+
+
+# --------------------------------------------------------------------------
+# Axis labels
+# --------------------------------------------------------------------------
+
+
+class _Run:
+    def __init__(self, context, future):
+        self.context, self.target_ts = context, future
+
+
+def _labels_match(bars, horizon):
+    """Every axis label must equal the timestamp actually plotted there."""
+    future = runtime.future_timestamps(bars, horizon)
+    hist = bars.tail(chart.HISTORY_BARS).reset_index(drop=True)
+    ts = pd.to_datetime(hist["ts"], utc=True)
+    n = len(hist)
+    scale = chart.Scale(n, horizon, 1.0, 2.0)
+
+    labels = chart._time_labels(ts, scale, n, horizon, future=future)
+    step = ts.diff().dropna().mode().iloc[0]
+    fmt = "%d %b" if step >= pd.Timedelta("1D") else "%d %H:%M"
+
+    for i, label in enumerate(labels):
+        idx = round((scale.slots - 1) * i / 5)
+        truth = (ts.iloc[idx] if idx < n else future[idx - n]).strftime(fmt)
+        assert label["label"] == truth, (
+            f"slot {idx}: axis says {label['label']}, bar is {truth}")
+    return labels
+
+
+def test_axis_labels_match_the_bars_on_a_session_market():
+    """Regression: these were out by eight days on SPY."""
+    _labels_match(_sessions(), 24)
+
+
+def test_axis_labels_match_the_bars_on_a_daily_market():
+    _labels_match(_daily(), 30)
+
+
+def test_axis_labels_match_the_bars_on_a_continuous_market():
+    _labels_match(_crypto(), 24)
+
+
+def test_daily_charts_label_the_month_not_the_clock():
+    """Every daily bar prints midnight, so the clock is noise."""
+    labels = _labels_match(_daily(), 30)
+    assert all(":" not in x["label"] for x in labels), labels
+    assert any(any(m in x["label"] for m in
+                   ("Jan", "Feb", "Mar", "Apr", "May", "Jun",
+                    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"))
+               for x in labels)
+
+
+def test_axis_labels_stay_on_the_canvas():
+    labels = _labels_match(_sessions(), 24)
+    for x in labels:
+        pct = float(x["left"].rstrip("%"))
+        assert 0.0 <= pct <= 100.0