| """Live performance from the Alpaca account: time-weighted return (deposits / withdrawals removed), drawdown, |
| and the S&P 500 (SPY) over the same days. |
| |
| Each point is tagged: "alpaca" (a daily close from the account's own history), "rebuilt" (a trading day Alpaca's |
| paper history has not posted yet — the account now, rolled back through every later fill and deposit, valued at |
| that day's closing prices) or "live" (today's equity from the account).""" |
| from __future__ import annotations |
|
|
| from datetime import date, datetime, timedelta, timezone |
| from typing import Optional |
| from zoneinfo import ZoneInfo |
|
|
| from . import config |
| from .broker import Alpaca |
|
|
|
|
| def twr(dates: list[str], equity: list[float], flows: dict[str, float]) -> list[float]: |
| """Growth of $1 (time-weighted): each day's return excludes that day's net deposit.""" |
| out, g = [], 1.0 |
| for i, (d, e) in enumerate(zip(dates, equity)): |
| if i > 0 and equity[i - 1] > 0: |
| g *= (e - flows.get(d, 0.0)) / equity[i - 1] |
| out.append(g) |
| return out |
|
|
|
|
| def bench_value(equity: list[float], spy_px: list, dates: list[str], flows: dict[str, float]) -> list: |
| """Dollar value of the S&P 500 holding the same money: starts at the account's first value and receives the |
| same deposits / withdrawals on the same days.""" |
| out, v, prev = [], None, None |
| for e, px, d in zip(equity, spy_px, dates): |
| if v is None: |
| v = e |
| elif px and prev: |
| v = v * px / prev + flows.get(d, 0.0) |
| out.append(round(v, 2) if v is not None else None) |
| prev = px or prev |
| return out |
|
|
|
|
| def rebuild(days: list[str], cash_now: float, qty_now: dict[str, float], fills: list[dict], |
| flows: dict[str, float], closes: dict[str, dict[str, float]]) -> dict[str, float]: |
| """Close-of-day equity for days missing from Alpaca's history. Holdings and cash on day d are today's minus |
| every fill and deposit dated after d; they are valued at d's closing prices. A day with a held stock lacking a |
| close is skipped.""" |
| out = {} |
| for d in days: |
| qty, cash = dict(qty_now), cash_now - sum(v for k, v in flows.items() if k > d) |
| for f in fills: |
| if f["date"] > d: |
| sgn = 1 if f["side"] == "buy" else -1 |
| qty[f["symbol"]] = qty.get(f["symbol"], 0.0) - sgn * f["qty"] |
| cash += sgn * f["qty"] * f["price"] |
| held = {s: q for s, q in qty.items() if abs(q) > 1e-9} |
| if all(d in closes.get(s, {}) for s in held): |
| out[d] = round(cash + sum(q * closes[s][d] for s, q in held.items()), 2) |
| return out |
|
|
|
|
| def _fills(a: Alpaca, since: str, ny: ZoneInfo) -> list[dict]: |
| after = datetime.fromisoformat(since).replace(tzinfo=ny) - timedelta(days=7) |
| out = [] |
| for o in a.orders(after=after, status="all"): |
| q, px, at = float(o.get("filled_qty") or 0), o.get("filled_avg_price"), o.get("filled_at") |
| if q > 0 and px and at: |
| when = datetime.fromisoformat(at.replace("Z", "+00:00")).astimezone(ny).date().isoformat() |
| out.append({"date": when, "symbol": o["symbol"], "side": o["side"], "qty": q, "price": float(px)}) |
| return out |
|
|
|
|
| def max_drawdown(g: list[float]) -> float: |
| peak, worst = 0.0, 0.0 |
| for x in g: |
| peak = max(peak, x) |
| worst = min(worst, x / peak - 1 if peak else 0.0) |
| return worst |
|
|
|
|
| def series(a: Alpaca, inception: Optional[str] = None) -> dict: |
| ny = ZoneInfo("America/New_York") |
| h = a.portfolio_history() |
| hist = {} |
| for t, e in zip(h.get("timestamp") or [], h.get("equity") or []): |
| if e is not None and float(e) > 0: |
| hist[datetime.fromtimestamp(t, ny).date().isoformat()] = float(e) |
| start = inception or config.INCEPTION |
| if not start: |
| first = [o for o in a.orders(status="all") if str(o.get("client_order_id", "")).startswith(config.TAG + "-")] |
| start = min((o["created_at"][:10] for o in first), default=None) |
| now = datetime.now(ny) |
| today = now.date().isoformat() |
| pts = sorted((d, e, "alpaca") for d, e in hist.items() if d < today) |
| if start: |
| before = [p for p in pts if p[0] < start] |
| pts = before[-1:] + [p for p in pts if p[0] >= start] |
| acct = a.account() |
| flows = {} |
| for f in a.cash_flows(): |
| flows[f["date"]] = flows.get(f["date"], 0.0) + f["amount"] |
| first_day = pts[0][0] if pts else (start or today) |
| bars = {b["t"]: b["c"] for b in a.daily_bars("SPY", date.fromisoformat(first_day) - timedelta(days=7))} |
| have = {p[0] for p in pts} |
| gaps = [d for d in sorted(bars) if pts and pts[0][0] < d < today and d not in have] |
| if gaps: |
| pos, fills = a.positions(), _fills(a, gaps[0], ny) |
| syms = set(pos) | {f["symbol"] for f in fills if f["date"] > gaps[0]} |
| closes = {s: {b["t"]: b["c"] for b in a.daily_bars(s, date.fromisoformat(gaps[0]), adjustment="raw")} |
| for s in syms} |
| got = rebuild(gaps, acct["cash"], {s: p["qty"] for s, p in pos.items()}, fills, flows, closes) |
| pts = sorted(pts + [(d, e, "rebuilt") for d, e in got.items()]) |
| if acct["equity"] > 0 and now.weekday() < 5: |
| pts.append((today, acct["equity"], "live")) |
| if len(pts) < 1: |
| return {"start": start, "dates": [], "strategy": [], "spy": [], "stats": {}} |
| dates, eq, src = [p[0] for p in pts], [p[1] for p in pts], [p[2] for p in pts] |
| g = twr(dates, eq, flows) |
| spy_now = a.latest_prices(["SPY"]).get("SPY") |
| if spy_now and dates[-1] == today: |
| bars[today] = spy_now |
| closes = sorted(bars.items()) |
| spy, j, last = [], 0, None |
| for d in dates: |
| while j < len(closes) and closes[j][0] <= d: |
| last = closes[j][1] |
| j += 1 |
| spy.append(last) |
| base = next((x for x in spy if x), None) |
| bench = bench_value(eq, spy, dates, flows) |
| spy = [round(x / base, 6) if (x and base) else None for x in spy] |
| days = (date.fromisoformat(dates[-1]) - date.fromisoformat(dates[0])).days |
| tot = g[-1] - 1 |
| spy_tot = (spy[-1] - 1) if spy and spy[-1] else None |
| ann = (g[-1] ** (365.25 / days) - 1) if days >= 365 else None |
| return {"start": start or dates[0], "base": dates[0], "dates": dates, "src": src, |
| "value": [round(x, 2) for x in eq], "bench_value": bench, "strategy": [round(x, 6) for x in g], "spy": spy, |
| "flows_today": flows.get(today, 0.0), |
| "stats": {"return": tot, "spy_return": spy_tot, "annualised": ann, "max_drawdown": max_drawdown(g), |
| "days": days, "equity": eq[-1]}} |
|
|
