live_runner.py

#!/usr/bin/env python3
"""
Entry point for live testnet execution.
Calibrates from prod API, runs on testnet, writes CSV log.

Usage:
    export BINANCE_TESTNET_KEY=...
    export BINANCE_TESTNET_SECRET=...
    python live_runner.py --scheduler AC --tactic GLFT --qty 1.0
"""
from __future__ import annotations

import argparse
import asyncio
import csv
import logging
import os
import sys
from dataclasses import asdict
from datetime import datetime
from pathlib import Path

import numpy as np
from binance import AsyncClient

from live_calibration import calibrate_live
from live_execution import LiveExecutor, FillRecord

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(name)s] %(message)s",
    datefmt="%H:%M:%S",
)
logger = logging.getLogger("live_runner")


def write_csv(fills: list[FillRecord], path: Path):
    if not fills:
        print("No fills to write.")
        return

    fieldnames = list(asdict(fills[0]).keys())

    with open(path, "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        for fill in fills:
            writer.writerow(asdict(fill))

    print(f"  Wrote {len(fills)} records to {path}")


def print_summary(fills: list[FillRecord], cal: dict):
    if not fills:
        print("No fills recorded.")
        return

    # Filter actual fills (not skips/cancels)
    actual_fills = [f for f in fills if f.fill_qty > 0]

    if not actual_fills:
        print("No actual fills (only skips/cancels).")
        return

    total_filled = sum(f.fill_qty for f in actual_fills)
    total_notional = sum(f.fill_price * f.fill_qty for f in actual_fills)
    avg_price = total_notional / total_filled if total_filled > 0 else 0
    arrival = actual_fills[0].mid_price

    is_bps = (arrival - avg_price) / arrival * 10000 if arrival > 0 else 0

    n_market = sum(1 for f in actual_fills if "MARKET" in f.action)
    n_limit = sum(1 for f in actual_fills if "LIMIT" in f.action)

    print(f"\n{'=' * 60}")
    print(f"  LIVE EXECUTION SUMMARY")
    print(f"{'=' * 60}")
    print(f"  Scheduler:    {actual_fills[0].scheduler}")
    print(f"  Tactic:       {actual_fills[0].tactic}")
    print(f"  Arrival mid:  ${arrival:,.2f}")
    print(f"  Avg fill:     ${avg_price:,.2f}")
    print(f"  IS:           {is_bps:+.2f} bps")
    print(f"  Total filled: {total_filled:.3f} BTC")
    print(f"  Completion:   {total_filled / cal['total_qty'] * 100:.1f}%")
    print(f"  Market fills: {n_market}")
    print(f"  Limit fills:  {n_limit}")

    # Latency stats
    if len(actual_fills) > 1:
        intervals = [
            actual_fills[i + 1].timestamp - actual_fills[i].timestamp
            for i in range(len(actual_fills) - 1)
        ]
        print(f"  Avg interval: {np.mean(intervals):.2f}s")

    print(f"{'=' * 60}")


def print_comparison(fills: list[FillRecord], backtest_csv: str | None):
    if backtest_csv is None or not Path(backtest_csv).exists():
        print("\n  No backtest baseline provided for comparison.")
        print("  Run: python run_multiday.py --mode oos --total-qty <qty>")
        print("  Then pass --backtest-csv results/multiday/oos/multiday_results.csv")
        return

    import pandas as pd
    bt = pd.read_csv(backtest_csv)

    actual_fills = [f for f in fills if f.fill_qty > 0]
    if not actual_fills:
        return

    sched = actual_fills[0].scheduler
    tactic = actual_fills[0].tactic

    # Map tactic names to backtest strategy names
    tactic_map = {"MARKET": "MktOrder", "GLFT": "GLFT", "PEG": "PegBest"}
    bt_strategy = f"{sched}+{tactic_map.get(tactic, tactic)}"

    bt_match = bt[bt["strategy"] == bt_strategy]
    if bt_match.empty:
        print(f"\n  No backtest match for {bt_strategy}")
        return

    total_filled = sum(f.fill_qty for f in actual_fills)
    total_notional = sum(f.fill_price * f.fill_qty for f in actual_fills)
    avg_price = total_notional / total_filled
    arrival = actual_fills[0].mid_price
    live_is = (arrival - avg_price) / arrival * 10000

    bt_is = bt_match["is_bps"].mean()

    print(f"\n{'=' * 60}")
    print(f"  LIVE vs BACKTEST COMPARISON -- {bt_strategy}")
    print(f"{'=' * 60}")
    print(f"  Live IS:     {live_is:+.2f} bps")
    print(f"  Backtest IS: {bt_is:+.2f} bps (avg across {len(bt_match)} days)")
    print(f"  Difference:  {live_is - bt_is:+.2f} bps")
    print(f"{'=' * 60}")
    print(f"\n  Note: testnet fills are at fake prices.")
    print(f"  The decision log (delta*, order prices) is the")
    print(f"  meaningful comparison, not the fill prices.")


async def run_live(args):
    """Main async entry point."""

    # 1. Calibrate
    logger.info("Starting calibration...")
    cal = calibrate_live(
        total_qty=args.qty,
        kline_lookback_hours=args.kline_hours,
        trade_lookback_minutes=args.trade_minutes,
        n_depth_snapshots=args.depth_snapshots,
    )

    if args.dry_run:
        logger.info("Dry run: calibration complete, skipping execution.")
        return

    # 2. Connect to testnet
    api_key = os.environ.get("BINANCE_TESTNET_KEY", "")
    api_secret = os.environ.get("BINANCE_TESTNET_SECRET", "")

    if not api_key or not api_secret:
        print("\nERROR: Set BINANCE_TESTNET_KEY and BINANCE_TESTNET_SECRET")
        print("Get them from: https://testnet.binancefuture.com")
        sys.exit(1)

    client = await AsyncClient.create(
        api_key=api_key,
        api_secret=api_secret,
        testnet=True,
    )
        # Set leverage to max (reduces margin requirement)
    try:
        await client.futures_change_leverage(symbol="BTCUSDT", leverage=125)
        logger.info("Set BTCUSDT leverage to 20x")
    except Exception as e:
        logger.warning(f"Could not set leverage: {e}")

    try:
        await client.futures_change_margin_type(symbol="BTCUSDT", marginType="CROSSED")
        logger.info("Set margin type to CROSSED")
    except Exception as e:
        logger.warning(f"Margin type: {e}")  # already CROSSED is fine
    try:
        # Check testnet balance
        account = await client.futures_account()
        balance = float(account.get("totalWalletBalance", 0))
        logger.info(f"Testnet balance: ${balance:,.2f}")

        # Configure margin
        try:
            await client.futures_change_margin_type(symbol="BTCUSDT", marginType="CROSSED")
            logger.info("Set margin type to CROSSED")
        except Exception as e:
            logger.warning(f"Margin type: {e}")

        try:
            await client.futures_change_leverage(symbol="BTCUSDT", leverage=20)
            logger.info("Set BTCUSDT leverage to 20x")
        except Exception as e:
            logger.warning(f"Could not set leverage: {e}")

        # 3. Run execution
        executor = LiveExecutor(
            client=client,
            cal=cal,
            scheduler_name=args.scheduler,
            tactic_name=args.tactic,
            check_interval=args.interval,
            order_size=0.01,
        )

        logger.info(
            f"Starting execution: {args.scheduler}+{args.tactic}, "
            f"{args.qty} BTC, {cal['horizon_sec']:.0f}s horizon"
        )

        await executor.run()

        # 4. Write results
        date_str = datetime.now().strftime("%Y%m%d_%H%M%S")
        output_dir = Path("results/live")
        output_dir.mkdir(parents=True, exist_ok=True)

        csv_path = output_dir / f"execution_log_{date_str}.csv"
        write_csv(executor.fills, csv_path)

        # 5. Print summary
        print_summary(executor.fills, cal)

        # 6. Compare with backtest if available
        print_comparison(executor.fills, args.backtest_csv)

    finally:
        await client.close_connection()


def main():
    parser = argparse.ArgumentParser(
        description="Live execution on Binance Futures Testnet"
    )
    parser.add_argument("--scheduler", type=str, default="AC",
                        choices=["AC", "TWAP"])
    parser.add_argument("--tactic", type=str, default="GLFT",
                        choices=["GLFT", "MARKET", "PEG"])
    parser.add_argument("--qty", type=float, default=1.0,
                        help="Total BTC to liquidate")
    parser.add_argument("--interval", type=float, default=1.0,
                        help="Control loop interval in seconds")
    parser.add_argument("--dry-run", action="store_true",
                        help="Calibrate only, don't execute")
    parser.add_argument("--backtest-csv", type=str, default=None,
                        help="Path to backtest results CSV for comparison")
    parser.add_argument("--kline-hours", type=int, default=24,
                        help="Hours of kline data for sigma calibration")
    parser.add_argument("--trade-minutes", type=int, default=10,
                        help="Minutes of trade data for A,k calibration")
    parser.add_argument("--depth-snapshots", type=int, default=10,
                        help="Number of book snapshots for eta calibration")
    args = parser.parse_args()

    asyncio.run(run_live(args))


if __name__ == "__main__":
    main()