aihf 2.2.0__tar.gz

aihf-2.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Virat Singh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aihf-2.2.0/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.1
+Name: aihf
+Version: 2.2.0
+Summary: An AI-powered hedge fund: LLM investor agents and quant alpha models you can build, backtest, and run from your terminal
+Home-page: https://github.com/virattt/ai-hedge-fund
+License: MIT
+Keywords: ai,hedge-fund,trading,llm,backtesting,agents
+Author: Virat Singh
+Author-email: virat.dot@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: langchain-anthropic (==0.3.5)
+Requires-Dist: langchain-deepseek (>=0.1.2,<0.2.0)
+Requires-Dist: langchain-google-genai (>=2.0.11,<3.0.0)
+Requires-Dist: langchain-openai (>=0.3.5,<0.4.0)
+Requires-Dist: langchain-xai (>=0.2.5,<0.3.0)
+Requires-Dist: matplotlib (>=3.9.2,<4.0.0)
+Requires-Dist: numpy (>=1.24.0,<2.0.0)
+Requires-Dist: pandas (>=2.1.0,<3.0.0)
+Requires-Dist: pydantic (>=2.4.2,<3.0.0)
+Requires-Dist: python-dotenv (==1.0.0)
+Requires-Dist: pyyaml (>=6.0.3,<7.0.0)
+Requires-Dist: requests (>=2.32.0,<3.0.0)
+Requires-Dist: rich (>=14.2.0,<15.0.0)
+Requires-Dist: scipy (>=1.11.0,<2.0.0)
+Requires-Dist: textual (>=8.2.8,<9.0.0)
+Project-URL: Repository, https://github.com/virattt/ai-hedge-fund
+Description-Content-Type: text/markdown
+
+# AI Hedge Fund
+
+This is a proof of concept for an AI-powered hedge fund. The goal of this project is to explore the use of AI to make trading decisions. This project is for **educational** purposes only and is not intended for real trading or investment.
+
+> **🚧 The project is evolving.** We're rebuilding it into a persistent, always-on AI hedge fund — a *fund* as a first-class entity you can backtest, paper-trade, and (opt-in) run live, with the investor agents reimagined as pluggable, backtestable "alpha models." Read the **[Vision →](VISION.md)** and the **[Roadmap →](ROADMAP.md)**.
+
+Note: the system does not actually make any trades.
+
+[![Twitter Follow](https://img.shields.io/twitter/follow/virattt?style=social)](https://twitter.com/virattt)
+
+## Disclaimer
+
+This project is for **educational and research purposes only**.
+
+- Not intended for real trading or investment
+- No investment advice or guarantees provided
+- Creator assumes no liability for financial losses
+- Consult a financial advisor for investment decisions
+- Past performance does not indicate future results
+
+By using this software, you agree to use it solely for learning purposes.
+
+## How to Install
+
+```bash
+pipx install aihf
+```
+
+(or `uv tool install aihf`, or `pip install aihf` into an environment of your choice)
+
+Then run it from anywhere:
+
+```bash
+aihf
+```
+
+### API keys
+
+The app asks for keys the first time it needs them and saves them to `~/.hedge-fund/.env` — nothing to configure up front. It needs:
+
+- A [Financial Datasets](https://financialdatasets.ai) API key, for prices, fundamentals, and earnings.
+- One LLM API key for the LLM-powered alpha models. Supported providers: Anthropic, OpenAI, DeepSeek, Google, xAI, Kimi.
+
+Keys exported in your shell always win over the saved file.
+
+## How to Run
+
+### Interactive app
+
+```bash
+aihf
+```
+
+With no arguments, this launches the interactive terminal app. Build a fund — pick stocks, strategies, rebalance cadence — or backtest a saved fund and watch its equity curve draw against its benchmark. Funds you build are saved as mandate files in `~/.hedge-fund/mandates/`.
+
+### Non-interactive
+
+Run one fund cycle from a mandate file. The full cycle record prints to stdout as JSON; a short human summary goes to stderr:
+
+```bash
+aihf ~/.hedge-fund/mandates/example.yaml --tickers AAPL,MSFT
+```
+
+Backtest the mandate over history at its rebalance cadence:
+
+```bash
+aihf ~/.hedge-fund/mandates/example.yaml --tickers AAPL,MSFT --backtest
+```
+
+A mandate is the desk — strategies, staff, risk, capital, cadence — and never names tickers; `--tickers` says what to point it at for this run.
+
+## Development
+
+```bash
+git clone https://github.com/virattt/ai-hedge-fund.git
+cd ai-hedge-fund
+poetry install
+poetry run aihf
+poetry run pytest hedge_fund
+```
+
+## How to Contribute
+
+1. Fork the repository
+2. Create a feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a Pull Request
+
+**Important**: Please keep your pull requests small and focused. This will make it easier to review and merge.
+
+## Feature Requests
+
+If you have a feature request, please open an [issue](https://github.com/virattt/ai-hedge-fund/issues) and make sure it is tagged with `enhancement`.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+

aihf-2.2.0/README.md

@@ -0,0 +1,98 @@
+# AI Hedge Fund
+
+This is a proof of concept for an AI-powered hedge fund. The goal of this project is to explore the use of AI to make trading decisions. This project is for **educational** purposes only and is not intended for real trading or investment.
+
+> **🚧 The project is evolving.** We're rebuilding it into a persistent, always-on AI hedge fund — a *fund* as a first-class entity you can backtest, paper-trade, and (opt-in) run live, with the investor agents reimagined as pluggable, backtestable "alpha models." Read the **[Vision →](VISION.md)** and the **[Roadmap →](ROADMAP.md)**.
+
+Note: the system does not actually make any trades.
+
+[![Twitter Follow](https://img.shields.io/twitter/follow/virattt?style=social)](https://twitter.com/virattt)
+
+## Disclaimer
+
+This project is for **educational and research purposes only**.
+
+- Not intended for real trading or investment
+- No investment advice or guarantees provided
+- Creator assumes no liability for financial losses
+- Consult a financial advisor for investment decisions
+- Past performance does not indicate future results
+
+By using this software, you agree to use it solely for learning purposes.
+
+## How to Install
+
+```bash
+pipx install aihf
+```
+
+(or `uv tool install aihf`, or `pip install aihf` into an environment of your choice)
+
+Then run it from anywhere:
+
+```bash
+aihf
+```
+
+### API keys
+
+The app asks for keys the first time it needs them and saves them to `~/.hedge-fund/.env` — nothing to configure up front. It needs:
+
+- A [Financial Datasets](https://financialdatasets.ai) API key, for prices, fundamentals, and earnings.
+- One LLM API key for the LLM-powered alpha models. Supported providers: Anthropic, OpenAI, DeepSeek, Google, xAI, Kimi.
+
+Keys exported in your shell always win over the saved file.
+
+## How to Run
+
+### Interactive app
+
+```bash
+aihf
+```
+
+With no arguments, this launches the interactive terminal app. Build a fund — pick stocks, strategies, rebalance cadence — or backtest a saved fund and watch its equity curve draw against its benchmark. Funds you build are saved as mandate files in `~/.hedge-fund/mandates/`.
+
+### Non-interactive
+
+Run one fund cycle from a mandate file. The full cycle record prints to stdout as JSON; a short human summary goes to stderr:
+
+```bash
+aihf ~/.hedge-fund/mandates/example.yaml --tickers AAPL,MSFT
+```
+
+Backtest the mandate over history at its rebalance cadence:
+
+```bash
+aihf ~/.hedge-fund/mandates/example.yaml --tickers AAPL,MSFT --backtest
+```
+
+A mandate is the desk — strategies, staff, risk, capital, cadence — and never names tickers; `--tickers` says what to point it at for this run.
+
+## Development
+
+```bash
+git clone https://github.com/virattt/ai-hedge-fund.git
+cd ai-hedge-fund
+poetry install
+poetry run aihf
+poetry run pytest hedge_fund
+```
+
+## How to Contribute
+
+1. Fork the repository
+2. Create a feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a Pull Request
+
+**Important**: Please keep your pull requests small and focused. This will make it easier to review and merge.
+
+## Feature Requests
+
+If you have a feature request, please open an [issue](https://github.com/virattt/ai-hedge-fund/issues) and make sure it is tagged with `enhancement`.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

aihf-2.2.0/hedge_fund/README.md

@@ -0,0 +1,119 @@
+# v2 — AI Hedge Fund core
+
+> **Status: Work in progress.** A ground-up rebuild of the engine, developed
+> alongside the shipped v1 app (`src/`, `app/`) but not yet wired into it.
+> See [`../VISION.md`](../VISION.md) and [`../ROADMAP.md`](../ROADMAP.md) for
+> where this is headed.
+
+v2 rebuilds the fund as a persistent, point-in-time-honest system, mirroring a
+real shop's hierarchy:
+
+```
+FUND      =  capital slices over STRATEGIES   (master risk on the netted book)
+STRATEGY  =  a blend policy over MODELS       (a "pod")
+MODEL     =  an alpha model → a Signal        (conviction in [-1,+1] + thesis)
+```
+
+A fund is the **desk**, not a watchlist: the mandate names no tickers. Which
+names to trade is supplied per run (`--tickers`, or the app's ticker prompt)
+and recorded on every `CycleRecord` — so one fund can be pointed at anything,
+and every run remembers what it traded.
+
+A fund runs two kinds of pods, like a real shop. **Discretionary** strategies
+are staffed by **agents** — LLM investor personas (Warren Buffett, Charlie
+Munger, Benjamin Graham, Peter Lynch, Stanley Druckenmiller) whose judgment
+is the edge; blend them long-biased or market-neutral. **Systematic**
+strategies are powered by quant models (post-earnings drift) — the model *is*
+the strategy, no persona attached. Both kinds implement one interface and
+plug into the same engine unchanged.
+
+Run a fund two ways: **one cycle** (today's data → today's target book) or a
+**backtest** — the same cycle looped over history at the mandate's rebalance
+cadence, producing an equity curve against your benchmark and a full
+`CycleRecord` for every tick. Same code path, so a backtest is honest by
+construction: it's the fund, replayed, not a separate simulator.
+
+## Quickstart
+
+```bash
+poetry install                          # dependencies
+
+# .env needs (at repo root):
+#   FINANCIAL_DATASETS_API_KEY=...      # market/fundamentals data
+#   ANTHROPIC_API_KEY=...               # only for LLM agents (Buffett)
+
+# THE command. No arguments: launch the interactive app (a Textual TUI).
+# Build a fund — pick stocks, strategies, rebalance cadence — or backtest a
+# saved fund and watch its equity curve draw against its benchmark.
+poetry run aihf       # or, equivalently: python -m hedge_fund.tui
+
+# With a mandate: run one cycle non-interactively (data → strategies →
+# netting → risk → execution), full CycleRecord as JSON on stdout. A mandate
+# carries no tickers — --tickers says what to point the fund at this run.
+poetry run aihf ~/.hedge-fund/mandates/example.yaml --tickers AAPL,MSFT,NVDA
+
+# Backtest a mandate: the same run_cycle looped over history at the
+# mandate's rebalance cadence, full result JSON (every CycleRecord) on stdout.
+poetry run aihf ~/.hedge-fund/mandates/example.yaml --tickers AAPL,MSFT --backtest
+
+# Tests
+poetry run pytest hedge_fund/
+```
+
+All API responses cache to disk (`~/.hedge-fund/cache/`), so reruns are fast,
+free, and work offline once warmed.
+
+## Architecture
+
+```
+Data (point-in-time) → Alpha models → Portfolio → Risk → Execution → Ledger
+```
+
+| Module | What | Status |
+|--------|------|--------|
+| `data/` | `DataClient` protocol, Financial Datasets client, disk cache | ✅ |
+| `signals/` | `AlphaModel` interface, PEAD, `LLMAgent` + 5 investor personas | ✅ |
+| `llm/` | LLM provider protocol, Anthropic client, prompt cache | ✅ |
+| `features/` | Point-in-time fundamentals snapshot (more features planned) | ◐ |
+| `fund/` | `FundSpec`/`StrategySpec` — mandates as YAML data — and the `Fund` object | ✅ |
+| `strategies/` | Strategy library (fundamental-ls, deep-value, inflections, earnings-drift) — add yours as a YAML | ✅ |
+| `portfolio/` | View blending → target weights (conviction-weighted, optional market-neutral) | ✅ |
+| `risk/` | Hard limits — per-position and gross-exposure clamps | ✅ |
+| `brokers/` | `Broker` protocol + `SimBroker` (paper/live brokers planned) | ◐ |
+| `pipeline/` | `run_cycle` — one code path for backtest/paper/live; `CycleRecord` | ✅ |
+| `backtesting/` | `backtest_fund` — the whole fund over history on `run_cycle` — plus the per-model engine | ✅ |
+| `event_study/` | Market-model abnormal returns (CARs) | ✅ |
+| `validation/` | Combinatorial purged CV (CPCV), backtest-overfitting prob (PBO) | ⬜ |
+| `tui/` | The interactive app (Textual): fund builder + live backtest board | ✅ |
+
+✅ built · ◐ partial · ⬜ planned
+
+## Principles (non-negotiable)
+
+- **Point-in-time by construction.** On any simulated date, only data actually
+  filed by then is visible — the data layer filters on filing date, not report
+  period. No lookahead, ever.
+- **Fail loud.** Infrastructure failures raise; only genuine "no data" returns
+  empty. A silent empty would poison a backtest as a fake "no signal."
+- **The LLM never touches the trade.** Agents form *views* and *narrate*;
+  deterministic code sizes and places orders; risk limits are hard gates.
+- **One interface for every analyst.** Implement `AlphaModel.predict(ticker,
+  date, data_client) -> Signal` and it plugs into the engine unchanged.
+
+## Data contracts (`models.py`)
+
+- `Signal` — an alpha model's output: `value` in `[-1, +1]`, plus `reasoning`,
+  `components`, and `metadata`.
+- `QuantSignals` — all signals for a ticker on a date.
+
+## Contributing
+
+Two high-leverage contributions:
+
+- **A new agent or quant model** (code): read `signals/base.py` for the
+  `AlphaModel` interface, use `signals/buffett.py` (an agent is just a system
+  prompt) or `signals/pead.py` (quant) as a template, register it, add a test.
+- **A new strategy** (no code): drop a YAML in `strategies/` bundling existing
+  models with a blend policy — the fund builder picks it up automatically.
+
+See [`../ROADMAP.md`](../ROADMAP.md) for the open list.

aihf-2.2.0/hedge_fund/__init__.py

@@ -0,0 +1,7 @@
+"""AI Hedge Fund v2 — quantitative trading stack.
+
+A clean-room rebuild focused on quant fundamentals:
+data pipelines, event studies, backtesting, validation,
+feature engineering, portfolio construction, risk management,
+and execution simulation.
+"""

aihf-2.2.0/hedge_fund/backtesting/__init__.py

@@ -0,0 +1,25 @@
+"""v2 backtesting — simulate a fund (or a single alpha model) over history."""
+
+from hedge_fund.backtesting.engine import BacktestEngine
+from hedge_fund.backtesting.fund import (
+    FundBacktestMetrics,
+    FundBacktestResult,
+    backtest_fund,
+    rebalance_grid,
+)
+from hedge_fund.backtesting.models import (
+    BacktestResult,
+    PerformanceMetrics,
+    Trade,
+)
+
+__all__ = [
+    "BacktestEngine",
+    "BacktestResult",
+    "FundBacktestMetrics",
+    "FundBacktestResult",
+    "PerformanceMetrics",
+    "Trade",
+    "backtest_fund",
+    "rebalance_grid",
+]

aihf-2.2.0/hedge_fund/backtesting/__main__.py

@@ -0,0 +1,190 @@
+"""Run the PEAD backtester. Screen-record friendly output.
+
+Usage: poetry run python -m hedge_fund.backtesting
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import time
+from datetime import date
+
+from hedge_fund.data import FDClient
+from hedge_fund.backtesting import BacktestEngine
+from hedge_fund.signals import PEADModel
+
+TICKERS = [
+    # Tech (21)
+    "AAPL", "MSFT", "AMZN", "GOOGL", "META", "NVDA", "TSLA", "NFLX", "CRM", "ADBE",
+    "ORCL", "INTC", "AMD", "CSCO", "IBM", "UBER", "SHOP", "SNOW", "PLTR", "PANW", "CRWD",
+    # Financials (15)
+    "JPM", "GS", "BAC", "WFC", "MS", "C", "BLK", "SCHW", "AXP", "COF",
+    "USB", "PNC", "TFC", "BK", "CME",
+    # Healthcare (15)
+    "JNJ", "PFE", "UNH", "MRK", "LLY", "ABBV", "TMO", "ABT", "BMY", "AMGN",
+    "GILD", "ISRG", "VRTX", "REGN", "MDT",
+    # Energy (7)
+    "XOM", "CVX", "COP", "SLB", "EOG", "MPC", "PSX",
+    # Consumer / Retail (15)
+    "HD", "LOW", "COST", "WMT", "KO", "PEP", "MCD", "SBUX", "NKE", "TGT",
+    "TJX", "ROST", "DG", "DLTR", "YUM",
+    # Industrials (10)
+    "CAT", "DE", "HON", "UPS", "RTX", "BA", "LMT", "GE", "MMM", "UNP",
+    # Media / Telecom (7)
+    "DIS", "CMCSA", "T", "VZ", "TMUS", "CHTR", "WBD",
+    # Other (10)
+    "V", "MA", "PYPL", "NEE", "D", "SO", "DUK", "ABNB", "COIN", "NOW",
+]
+
+HOLDING_DAYS = 5
+CAPITAL = 100_000.0
+PER_TRADE = 10_000.0
+START_DATE = "2024-06-01"
+END_DATE = date.today().isoformat()
+
+# Colors
+GREEN = "\033[32m"
+RED = "\033[31m"
+YELLOW = "\033[33m"
+CYAN = "\033[36m"
+DIM = "\033[90m"
+BOLD = "\033[1m"
+RESET = "\033[0m"
+
+
+def clear():
+    os.system("clear")
+
+
+def color_pnl(v: float) -> str:
+    c = GREEN if v >= 0 else RED
+    return f"{c}${v:>+10,.2f}{RESET}"
+
+
+def color_pct(v: float) -> str:
+    c = GREEN if v >= 0 else RED
+    return f"{c}{v:>+7.2%}{RESET}"
+
+
+def color_direction(d: str) -> str:
+    return f"{GREEN}LONG {RESET}" if d == "long" else f"{RED}SHORT{RESET}"
+
+
+def color_eps(s: str | None) -> str:
+    if s == "BEAT":
+        return f"{GREEN}BEAT{RESET}"
+    if s == "MISS":
+        return f"{RED}MISS{RESET}"
+    return f"{DIM}  - {RESET}"
+
+
+def print_header(metrics, equity: float):
+    """Print the portfolio summary dashboard."""
+    m = metrics
+    ret_color = GREEN if m.total_return_pct >= 0 else RED
+    sharpe_color = GREEN if m.sharpe_ratio > 1.0 else YELLOW if m.sharpe_ratio > 0 else RED
+
+    print(f"  {BOLD}PEAD Backtest — Long BEATs, Short MISSes, {HOLDING_DAYS}-day hold{RESET}")
+    print(f"  {DIM}{'─' * 70}{RESET}")
+    print(
+        f"  Portfolio: {CYAN}${equity:>12,.2f}{RESET}"
+        f"    Return: {ret_color}{m.total_return_pct:>+7.2%}{RESET}"
+        f"    Sharpe: {sharpe_color}{m.sharpe_ratio:>5.2f}{RESET}"
+        f"    Max DD: {RED}{m.max_drawdown_pct:>6.2%}{RESET}"
+    )
+    print(
+        f"  Trades: {m.n_trades}"
+        f"  ({GREEN}{m.n_long} long{RESET}, {RED}{m.n_short} short{RESET})"
+        f"    Win Rate: {m.win_rate:.0%}"
+        f"    Avg Return: {color_pct(m.avg_return_pct)}"
+    )
+    print(f"  {DIM}{'─' * 70}{RESET}")
+    print()
+
+
+def print_table_header():
+    print(
+        f"  {DIM}{'Date':<12} {'Ticker':<6} {'Action':<6} {'EPS':<5}"
+        f" {'Entry':>9} {'Exit':>9} {'Shares':>7}"
+        f" {'P&L':>12} {'Return':>8}{RESET}"
+    )
+    print(f"  {DIM}{'─' * 78}{RESET}")
+
+
+def print_trade_row(t):
+    print(
+        f"  {t.entry_date:<12} {CYAN}{t.ticker:<6}{RESET}"
+        f" {color_direction(t.direction)} {color_eps(t.metadata.get('eps_surprise'))}"
+        f" ${t.entry_price:>8.2f} ${t.exit_price:>8.2f} {t.shares:>7.1f}"
+        f" {color_pnl(t.pnl)} {color_pct(t.return_pct)}"
+    )
+
+
+def main() -> None:
+    import logging
+    logging.getLogger("hedge_fund.data.client").setLevel(logging.ERROR)
+
+    n = len(TICKERS)
+    engine = BacktestEngine(capital=CAPITAL, per_trade=PER_TRADE)
+    model = PEADModel()
+
+    # Phase 1: Backtest the PEAD alpha model, ticker by ticker, with progress
+    sys.stdout.write(f"  Backtesting PEAD alpha... [0/{n}]")
+    sys.stdout.flush()
+
+    trades = []
+    with FDClient() as fd:
+        for i, ticker in enumerate(TICKERS):
+            sys.stdout.write(f"\r  Backtesting PEAD alpha... [{i + 1}/{n}] {ticker:<6}")
+            sys.stdout.flush()
+            r = engine.run_alpha(
+                model, [ticker], fd, START_DATE, END_DATE, holding_days=HOLDING_DAYS,
+            )
+            trades.extend(r.trades)
+
+    sys.stdout.write(f"\r  Backtesting PEAD alpha... {len(trades)} trades" + " " * 20 + "\n")
+    sys.stdout.flush()
+    time.sleep(0.5)
+
+    if not trades:
+        print("  No trades generated.")
+        return
+
+    trades.sort(key=lambda t: t.entry_date)
+
+    # Phase 2: Replay trades one by one with running metrics
+    clear()
+    equity = CAPITAL
+    displayed: list = []
+
+    for trade in trades:
+        equity += trade.pnl
+        displayed.append(trade)
+
+        # Rebuild display each trade (like v1's clear-and-reprint)
+        clear()
+
+        # Compute running metrics over the trades shown so far
+        running_curve = engine._build_equity_curve(displayed)
+        running_metrics = engine._compute_metrics(displayed, running_curve)
+
+        print_header(running_metrics, equity)
+        print_table_header()
+
+        # Print all trades so far (newest first)
+        for t in reversed(displayed):
+            print_trade_row(t)
+
+        print()
+        time.sleep(0.4)
+
+    # Final summary
+    time.sleep(0.5)
+    print(f"  {BOLD}Done.{RESET} {len(trades)} trades executed.\n")
+
+
+if __name__ == "__main__":
+    from hedge_fund.tui.keys import apply_credentials
+    apply_credentials()
+    main()