alphafinch 0.1.0__py3-none-any.whl

alphafinch/braille.py

@@ -0,0 +1,66 @@
+"""Terminal line charts.
+
+`chart` draws solid lines with box-drawing characters (asciichart style), which render
+crisply in any monospace font. Several series share one y-axis; later series draw on top.
+"""
+from __future__ import annotations
+
+import numpy as np
+from rich.text import Text
+
+
+def _resample(y: np.ndarray, n: int) -> np.ndarray:
+    """Average within each column (smooths daily noise instead of sampling it)."""
+    if len(y) <= n:
+        idx = np.linspace(0, len(y) - 1, n)
+        return np.interp(idx, np.arange(len(y)), y)
+    edges = np.linspace(0, len(y), n + 1).astype(int)
+    return np.array([y[a:b].mean() for a, b in zip(edges[:-1], edges[1:])])
+
+
+def chart(series: list[tuple[np.ndarray, str]], width: int = 56, height: int = 12,
+          upto: float = 1.0, log: bool = True) -> Text:
+    """Render series (values, rich style) as solid lines. `upto` in (0, 1] draws only the
+    first fraction of each series, for animation."""
+    ys = []
+    for v, _ in series:
+        v = np.asarray(v, float)
+        ys.append(np.log(v) if log else v)
+    cols = max(2, width)
+    rs = [_resample(y, cols) for y in ys]
+    lo = min(float(r.min()) for r in rs)
+    hi = max(float(r.max()) for r in rs)
+    span = hi - lo if hi > lo else 1.0
+    grid = [[" "] * cols for _ in range(height)]
+    style = [[""] * cols for _ in range(height)]
+    last = max(2, int(cols * upto))
+    LIGHT = dict(h="─", up_from="╯", up_to="╭", down_from="╮", down_to="╰", v="│")
+    HEAVY = dict(h="━", up_from="┛", up_to="┏", down_from="┓", down_to="┗", v="┃")
+    for r, (_, st) in zip(rs, series):
+        g = HEAVY if "bold" in st else LIGHT
+        rows = np.round((1 - (r - lo) / span) * (height - 1)).astype(int)
+        for x in range(last):
+            y0 = rows[x]
+            if x == 0:
+                grid[y0][x], style[y0][x] = g["h"], st
+                continue
+            yp = rows[x - 1]
+            if y0 == yp:
+                grid[y0][x], style[y0][x] = g["h"], st
+            elif y0 < yp:                       # going up (smaller row index)
+                grid[yp][x], style[yp][x] = g["up_from"], st
+                grid[y0][x], style[y0][x] = g["up_to"], st
+                for k in range(y0 + 1, yp):
+                    grid[k][x], style[k][x] = g["v"], st
+            else:                               # going down
+                grid[yp][x], style[yp][x] = g["down_from"], st
+                grid[y0][x], style[y0][x] = g["down_to"], st
+                for k in range(yp + 1, y0):
+                    grid[k][x], style[k][x] = g["v"], st
+    out = Text()
+    for r in range(height):
+        for c in range(cols):
+            out.append(grid[r][c], style=style[r][c])
+        if r < height - 1:
+            out.append("\n")
+    return out

alphafinch/cinema.py

@@ -0,0 +1,238 @@
+"""`alphafinch replay`: re-animate a finished run as a short cinematic story.
+
+Every frame is reconstructed from the run's saved population (code, lineage, operators) and
+from re-running the strategies on the same data, so nothing is invented. Scenes:
+  1. title card
+  2. births: the AI writing new strategies (changed lines highlighted) while their training
+     equity curves draw against their parent and the market; new champions are crowned
+  3. the sealed exam: the hidden years are unsealed and the verdict revealed
+  4. end card
+"""
+from __future__ import annotations
+
+import difflib
+import json
+import time
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from rich.align import Align
+from rich.console import Console, Group
+from rich.live import Live
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from . import data, fitness
+from .lab import Lab
+from .braille import chart
+from .ui import OP_ICON
+
+OP_VERB = {"mutate": "mutating", "crossover": "crossing", "immigrant": "inventing", "tweak": "tuning",
+           "blend": "blending", "seed": "planting"}
+
+
+def exam_reveal(live, name, span, mkt_hold, rev, verdict, bar, width, sleep):
+    """The dramatic ending: unseal the hidden years, draw the champion against the market,
+    stamp the verdict."""
+    for k in range(0, 21):
+        prog = "█" * k + "░" * (20 - k)
+        live.update(Panel(Group(Align.center(Text("🔒  THE SEALED EXAM", style="bold #f9e2af")),
+                                Align.center(Text(f"{name} has never seen {span}", style="grey62")),
+                                Text(""), Align.center(Text(f"unsealing  {prog}", style="#f9e2af"))),
+                          border_style="#f9e2af", width=width, padding=(1, 2)), refresh=True)
+        sleep(0.05)
+    curves = [(mkt_hold, "#6c7086"), (rev["equity"].values, "bold #a6e3a1")]
+    leg = Text()
+    for label, col in [("buy everything (equal weight)", "#6c7086"), (name, "bold #a6e3a1")]:
+        leg.append("━━ ", style=col)
+        leg.append(label + "    ")
+    panel = None
+    for k in range(1, 36):
+        panel = Panel(Group(chart(curves, width=width - 6, height=12, upto=k / 35), Text(""), leg),
+                      title=f"🔒 the sealed years, {span}: growth of $1", border_style="#f9e2af", width=width)
+        live.update(panel, refresh=True)
+        sleep(0.05)
+    grade = rev.get("grade", verdict)
+    passed = grade == "PASS"
+    label, colour = {"PASS": ("  ✅ PASS  ", "#1a7f37"), "PROMISING": ("  🤔 PROMISING  ", "#9a6700"),
+                     "FAIL": ("  ❌ FAIL  ", "#cf222e")}[grade]
+    stamp = Text.assemble((label, f"bold #ffffff on {colour}"),
+                          (f"   sealed-years alpha {rev['alpha']:+.1%}/yr  ·  t = {rev['alpha_t']:.2f}  ·  bar {bar:.2f}", "white"))
+    if passed:
+        moral = Text("  It beat the market by more than luck can explain.", style="bold #a6e3a1")
+    else:
+        mkt_cagr = mkt_hold[-1] ** (252 / max(len(mkt_hold) - 1, 1)) - 1
+        yn = rev.get("years_needed")
+        if grade == "PROMISING":
+            tail = f"Promising: an edge this size needs ~{yn:.0f} years of data to prove." if yn else "Promising, but unproven."
+        else:
+            tail = "No proof of a real edge."
+        moral = Text(f"  It made {rev['cagr']:+.0%} a year; buying everything made {mkt_cagr:+.0%}. {tail}",
+                     style="bold #f9e2af")
+    live.update(Group(panel, stamp, moral), refresh=True)
+    sleep(3.5)
+
+
+class Cinema:
+    def __init__(self, run_dir: Path, speed: float = 1.0, width: int = 118):
+        self.dir = Path(run_dir)
+        self.speed = speed
+        self.pop = json.loads((self.dir / "population.json").read_text())
+        self.by_id = {p["id"]: p for p in self.pop}
+        meta_f = self.dir / "meta.json"
+        self.meta = json.loads(meta_f.read_text()) if meta_f.exists() else {}
+        self.console = Console(width=width)
+        self.width = width
+
+    # helpers ---------------------------------------------------------------------------------
+    def _sleep(self, s):
+        time.sleep(s / self.speed)
+
+    def _equity(self, code):
+        r = self.lab.run(code, "train", check_leaks=False).returns
+        return (1 + r).cumprod().values
+
+    def _code_panel(self, ind, parent_code, shown_lines, title_extra=""):
+        lines = ind["code"].rstrip().splitlines()
+        new = set()
+        if parent_code:
+            pl = [l.strip() for l in parent_code.splitlines()]
+            new = {i for i, l in enumerate(lines) if l.strip() and l.strip() not in pl}
+        else:
+            new = set(range(len(lines)))
+        body = Text()
+        for i, l in enumerate(lines[:shown_lines][-16:]):
+            idx = i + max(0, shown_lines - 16)
+            mark, style = ("+ ", "bold green") if idx in new else ("  ", "grey70")
+            body.append(mark, style="green" if idx in new else "grey35")
+            body.append(l[:60] + "\n", style=style)
+        if shown_lines < len(lines):
+            body.append("▌", style="bold white blink")
+        verb = OP_VERB.get(ind["op"], ind["op"])
+        parents = " + ".join(self.by_id[p]["name"] for p in ind["parents"] if p in self.by_id) or "a new idea"
+        return Panel(body, title=f"{OP_ICON.get(ind['op'], '•')}  the AI is {verb}: [bold]{ind['name']}[/]{title_extra}",
+                     subtitle=f"[grey62]from {parents}[/]", border_style="magenta", height=20, width=68)
+
+    def _chart_panel(self, curves, upto, title, legend):
+        c = chart(curves, width=self.width - 72, height=15, upto=upto)
+        leg = Text()
+        for name, colour in legend:
+            leg.append("━━ ", style=colour)
+            leg.append(name + "   ", style="white")
+        return Panel(Group(c, Text(""), leg), title=title, border_style="cyan", height=20, width=self.width - 68)
+
+    def _header(self, gen, bred, champ_name, champ_fit):
+        t = Text.assemble(("🐦 AlphaFinch  ", "bold magenta"),
+                          (f"{self.meta.get('market_label', 'market')}  ", "bold"),
+                          (f"generation {gen}  ", "cyan"), (f"strategies bred {bred}  ", "white"),
+                          ("👑 ", ""), (f"{champ_name} ", "bold green"), (f"{champ_fit:+.2f}", "green"))
+        return Panel(t, border_style="magenta", width=self.width)
+
+    # scenes ----------------------------------------------------------------------------------
+    def _prepare(self):
+        market = self.meta.get("market", "us")
+        tickers = self.meta.get("tickers")
+        px = data.load(market, tickers.split(",") if tickers else None, self.meta.get("start"))
+        hold = pd.Timestamp(self.meta["holdout_start"])
+        self.lab = Lab(px, hold, workers=2)
+        self.mkt_train = (1 + self.lab.mkt["train"]).cumprod().values
+        ordered = sorted([p for p in self.pop if p["fitness"] is not None], key=lambda p: p["id"])
+        self.seeds = [p for p in ordered if p["op"] == "seed"]
+        self.children = [p for p in ordered if p["op"] not in ("seed", "migrant")]
+        self.stillborn = [p for p in self.pop if p["error"]]
+        best, rec = max(s["fitness"] for s in self.seeds), []
+        ai_ops = ("mutate", "crossover", "immigrant")
+        for c in self.children:                     # every new record holder
+            if c["fitness"] > best + 1e-9:
+                best = c["fitness"]
+                rec.append(c["id"])
+        ai_rec = [r for r in rec if self.by_id[r]["op"] in ai_ops]
+        self.featured = (ai_rec or rec)[-3:]
+        by_id = {p["id"]: p for p in ordered}
+        self.champ = by_id.get(self.meta.get("champion_id")) or max(ordered, key=lambda p: p["fitness"])
+        self.eq = {}
+        for cid in self.featured:
+            c = self.by_id[cid]
+            par = self.by_id.get(c["parents"][0]) if c["parents"] else None
+            self.eq[cid] = self._equity(c["code"])
+            if par:
+                self.eq[par["id"]] = self._equity(par["code"])
+        self.exam = fitness.SealedExam(self.lab, budget=self.meta.get("exam_budget", 10),
+                                       alpha=self.meta.get("alpha", 0.05))
+        self.rev = self.exam.reveal(self.champ["id"], self.champ["code"])
+        self.mkt_hold = self.rev["market_equity"].values
+        self.lab.close()
+        self.span = f"{hold.strftime('%b %Y')} – {px.index[-1].strftime('%b %Y')}"
+        v = next((e["verdict"] for e in self.meta.get("exam", []) if e["id"] == self.champ["id"]), None)
+        self.verdict = v or ("PASS" if self.rev["alpha_t"] > self.exam.bar else "FAIL")
+
+    def run(self):
+        with self.console.status("[magenta]⏪ rewinding the run…"):
+            self._prepare()
+        islands = self.meta.get("islands", 4)
+        model = self.meta.get("model") or self.meta.get("provider") or "AI"
+        model = {"sonnet": "Claude Sonnet", "opus": "Claude Opus"}.get(model, model)
+        feed: list[Text] = []
+
+        def frame(*parts):
+            return Group(*parts)
+
+        with Live(console=self.console, auto_refresh=False, screen=False, transient=False) as live:
+            # 1. title ---------------------------------------------------------------------------
+            title = Group(Align.center(Text("🐦  AlphaFinch", style="bold magenta")),
+                          Align.center(Text("AI breeds trading strategies. A sealed exam decides if they're real.")),
+                          Text(""),
+                          Align.center(Text(f"{self.meta.get('market_label', '')}  ·  {islands} islands  ·  bred by {model}",
+                                            style="grey62")))
+            live.update(Panel(title, border_style="magenta", width=self.width, padding=(1, 2)), refresh=True)
+            self._sleep(2.0)
+
+            # 2. births --------------------------------------------------------------------------
+            cur = max(self.seeds, key=lambda p: p["fitness"])
+            bred = 0
+            for c in self.children:
+                bred += 1
+                line = Text.assemble((f" {OP_ICON.get(c['op'], '•')} ", ""), (f"{c['name']:<30}", "white"),
+                                     (f"{c['op']:<10}", "grey50"), (f"fitness {c['fitness']:+.2f}", "grey62"))
+                if c["id"] not in self.featured:
+                    feed.append(line)
+                    live.update(frame(self._header(c["gen"], bred, cur["name"], cur["fitness"]),
+                                      Panel(Group(*feed[-12:]), title="🐣 strategies being born", border_style="grey35",
+                                            width=self.width, height=14)), refresh=True)
+                    self._sleep(0.09)
+                    continue
+                par = self.by_id.get(c["parents"][0]) if c["parents"] else None
+                curves = [(self.mkt_train, "#6c7086")] + ([(self.eq[par["id"]], "#89b4fa")] if par else []) + [(self.eq[c["id"]], "bold #a6e3a1")]
+                legend = [("market", "#6c7086")] + ([("parent", "#89b4fa")] if par else []) + [(c["name"][:22], "bold #a6e3a1")]
+                n_lines = len(c["code"].splitlines())
+                steps = 30
+                row = None
+                for k in range(1, steps + 1):
+                    shown = int(n_lines * min(1, k / (steps * 0.55)))
+                    upto = min(1.0, max(0.03, (k - steps * 0.3) / (steps * 0.6)))
+                    row = Table.grid()
+                    row.add_row(self._code_panel(c, par["code"] if par else None, shown),
+                                self._chart_panel(curves, upto, "📈 growth of $1 (training years)", legend))
+                    live.update(frame(self._header(c["gen"], bred, cur["name"], cur["fitness"]), row), refresh=True)
+                    self._sleep(0.06)
+                beat = f"  beats {par['name']} ({par['fitness']:+.2f})" if par else ""
+                crown = Text.assemble(("  👑 NEW CHAMPION  ", "bold #1e1e2e on #f9e2af"), ("  ", ""), (c["name"], "bold #f9e2af"),
+                                      (f"   fitness {c['fitness']:+.2f}{beat}", "#f9e2af"))
+                cur = c
+                live.update(frame(self._header(c["gen"], bred, cur["name"], cur["fitness"]), row, crown), refresh=True)
+                self._sleep(1.8)
+                feed.append(Text.assemble((" 👑 ", ""), (f"{c['name']:<30}", "bold #f9e2af"), (f"{c['op']:<10}", "grey50"),
+                                          (f"fitness {c['fitness']:+.2f}", "#f9e2af")))
+
+            # 3. the sealed exam -------------------------------------------------------------------
+            exam_reveal(live, self.champ["name"], self.span, self.mkt_hold, self.rev, self.verdict,
+                        self.exam.bar, self.width, self._sleep)
+
+            # 4. end card ------------------------------------------------------------------------
+            live.update(Panel(Group(Align.center(Text("🐦  AlphaFinch", style="bold magenta")),
+                                    Align.center(Text("evolve strategies while you sleep · an exam they can't cheat")),
+                                    Text(""), Align.center(Text("pip install alphafinch", style="bold cyan"))),
+                              border_style="magenta", width=self.width, padding=(1, 2)), refresh=True)
+            self._sleep(2.5)