weatherbot/bot_v2.py

#!/usr/bin/env python3
"""
Weather Trading Bot v2 — Polymarket
Kelly Criterion + Expected Value simulation.

Usage:
    python bot_v2.py           # Paper mode with $1000 virtual balance
    python bot_v2.py --live    # Simulate trades against real prices
    python bot_v2.py --positions
    python bot_v2.py --reset   # Reset simulation balance
    python bot_v2.py --monitor # Live price monitor, updates dashboard every 10s
"""

import re
import json
import argparse
import requests
from datetime import datetime, timezone, timedelta

# =============================================================================
# CONFIG
# =============================================================================

with open("config.json") as f:
    _cfg = json.load(f)

ENTRY_THRESHOLD   = _cfg.get("entry_threshold", 0.15)
EXIT_THRESHOLD    = _cfg.get("exit_threshold", 0.45)
MAX_TRADES        = _cfg.get("max_trades_per_run", 5)
MIN_HOURS_LEFT    = _cfg.get("min_hours_to_resolution", 2)
PRICE_DROP_SIGNAL = _cfg.get("price_drop_threshold", 0.10)

# Kelly + EV settings
NOAA_ACCURACY     = 0.78        # NOAA forecast accuracy for 1-3 day predictions
KELLY_FRACTION    = 0.25        # Use 1/4 Kelly for safety
MAX_POSITION_PCT  = 0.10        # Never bet more than 10% of balance on one trade
MIN_EV            = 0.05        # Minimum EV to enter
SIM_BALANCE       = 1000.0      # Starting virtual balance

# Airport coordinates — match the exact stations Polymarket resolves on
LOCATIONS = {
    "nyc":     {"lat": 40.7772, "lon": -73.8726, "name": "New York City"},  # KLGA LaGuardia
    "chicago": {"lat": 41.9742, "lon": -87.9073, "name": "Chicago"},        # KORD O'Hare
    "miami":   {"lat": 25.7959, "lon": -80.2870, "name": "Miami"},          # KMIA
    "dallas":  {"lat": 32.8471, "lon": -96.8518, "name": "Dallas"},         # KDAL Love Field
    "seattle": {"lat": 47.4502, "lon": -122.3088, "name": "Seattle"},       # KSEA Sea-Tac
    "atlanta": {"lat": 33.6407, "lon": -84.4277,  "name": "Atlanta"},       # KATL Hartsfield
}

# NWS hourly endpoints per city
NWS_ENDPOINTS = {
    "nyc":     "https://api.weather.gov/gridpoints/OKX/37,39/forecast/hourly",
    "chicago": "https://api.weather.gov/gridpoints/LOT/66,77/forecast/hourly",
    "miami":   "https://api.weather.gov/gridpoints/MFL/106,51/forecast/hourly",
    "dallas":  "https://api.weather.gov/gridpoints/FWD/87,107/forecast/hourly",
    "seattle": "https://api.weather.gov/gridpoints/SEW/124,61/forecast/hourly",
    "atlanta": "https://api.weather.gov/gridpoints/FFC/50,82/forecast/hourly",
}

# Station IDs for real observations
STATION_IDS = {
    "nyc": "KLGA", "chicago": "KORD", "miami": "KMIA",
    "dallas": "KDAL", "seattle": "KSEA", "atlanta": "KATL",
}

ACTIVE_LOCATIONS = _cfg.get("locations", "nyc,chicago,miami,dallas,seattle,atlanta").split(",")
ACTIVE_LOCATIONS = [l.strip().lower() for l in ACTIVE_LOCATIONS]

MONTHS = ["january","february","march","april","may","june",
          "july","august","september","october","november","december"]

# =============================================================================
# COLORS
# =============================================================================

class C:
    GREEN  = "\033[92m"
    YELLOW = "\033[93m"
    RED    = "\033[91m"
    CYAN   = "\033[96m"
    GRAY   = "\033[90m"
    RESET  = "\033[0m"
    BOLD   = "\033[1m"

def ok(msg):   print(f"{C.GREEN}  ✅ {msg}{C.RESET}")
def warn(msg): print(f"{C.YELLOW}  ⚠️  {msg}{C.RESET}")
def info(msg): print(f"{C.CYAN}  {msg}{C.RESET}")
def skip(msg): print(f"{C.GRAY}  ⏸️  {msg}{C.RESET}")

# =============================================================================
# KELLY CRITERION + EV
# =============================================================================

def calculate_ev(our_prob: float, market_price: float) -> float:
    """
    Expected Value per $1 risked.
    EV = (our_prob * payout) - (1 - our_prob)
    payout = (1 / market_price) - 1

    Example: our_prob=0.75, price=0.08
    payout = 1/0.08 - 1 = 11.5x
    EV = 0.75 * 11.5 - 0.25 = +$8.12 per $1 risked
    """
    if market_price <= 0 or market_price >= 1:
        return 0.0
    payout = (1.0 / market_price) - 1.0
    ev = (our_prob * payout) - (1.0 - our_prob)
    return round(ev, 4)


def calculate_kelly(our_prob: float, market_price: float) -> float:
    """
    Kelly Criterion: optimal fraction of bankroll to bet.
    f* = (p * b - q) / b

    We apply KELLY_FRACTION (0.25) for safety — fractional Kelly.
    Result is capped at MAX_POSITION_PCT (10% of balance).
    """
    if market_price <= 0 or market_price >= 1:
        return 0.0
    b = (1.0 / market_price) - 1.0
    p = our_prob
    q = 1.0 - p
    kelly = (p * b - q) / b
    kelly = max(0.0, kelly)
    kelly = kelly * KELLY_FRACTION
    kelly = min(kelly, MAX_POSITION_PCT)
    return round(kelly, 4)


def calculate_position_size(kelly_fraction: float, balance: float) -> float:
    return round(kelly_fraction * balance, 2)

# =============================================================================
# SIMULATION STATE
# =============================================================================

SIM_FILE = "simulation.json"

def load_sim() -> dict:
    try:
        with open(SIM_FILE) as f:
            return json.load(f)
    except FileNotFoundError:
        return {
            "balance": SIM_BALANCE,
            "starting_balance": SIM_BALANCE,
            "positions": {},
            "trades": [],
            "total_trades": 0,
            "wins": 0,
            "losses": 0,
            "peak_balance": SIM_BALANCE,
        }

def save_sim(sim: dict):
    with open(SIM_FILE, "w") as f:
        json.dump(sim, f, indent=2)

def reset_sim():
    import os
    if os.path.exists(SIM_FILE):
        os.remove(SIM_FILE)
    print(f"{C.GREEN}  ✅ Simulation reset — balance back to ${SIM_BALANCE:.2f}{C.RESET}")

# =============================================================================
# NWS FORECAST
# =============================================================================

def get_forecast(city_slug: str) -> dict:
    """
    Fetch daily max temperature from NWS.
    Combines real station observations (past hours today) with
    hourly forecast (upcoming hours) to get the true daily maximum.
    """
    forecast_url = NWS_ENDPOINTS.get(city_slug)
    station_id = STATION_IDS.get(city_slug)
    daily_max = {}
    headers = {"User-Agent": "weatherbot/1.0"}

    # Real observations — what already happened today
    try:
        obs_url = f"https://api.weather.gov/stations/{station_id}/observations?limit=48"
        r = requests.get(obs_url, timeout=10, headers=headers)
        for obs in r.json().get("features", []):
            props = obs["properties"]
            time_str = props.get("timestamp", "")[:10]
            temp_c = props.get("temperature", {}).get("value")
            if temp_c is not None:
                temp_f = round(temp_c * 9/5 + 32)
                if time_str not in daily_max or temp_f > daily_max[time_str]:
                    daily_max[time_str] = temp_f
    except Exception as e:
        warn(f"Observations error for {city_slug}: {e}")

    # Hourly forecast — upcoming hours
    try:
        r = requests.get(forecast_url, timeout=10, headers=headers)
        periods = r.json()["properties"]["periods"]
        for p in periods:
            date = p["startTime"][:10]
            temp = p["temperature"]
            if p.get("temperatureUnit") == "C":
                temp = round(temp * 9/5 + 32)
            if date not in daily_max or temp > daily_max[date]:
                daily_max[date] = temp
    except Exception as e:
        warn(f"Forecast error for {city_slug}: {e}")

    return daily_max

# =============================================================================
# POLYMARKET API
# =============================================================================

def get_polymarket_event(city_slug: str, month: str, day: int, year: int) -> dict:
    slug = f"highest-temperature-in-{city_slug}-on-{month}-{day}-{year}"
    url = f"https://gamma-api.polymarket.com/events?slug={slug}"
    try:
        r = requests.get(url, timeout=10)
        data = r.json()
        if data and isinstance(data, list) and len(data) > 0:
            return data[0]
    except Exception as e:
        warn(f"Polymarket API error: {e}")
    return None

def get_price_history(market_id: str) -> list:
    url = f"https://clob.polymarket.com/prices-history?market={market_id}&interval=1d&fidelity=60"
    try:
        r = requests.get(url, timeout=10)
        return r.json().get("history", [])
    except Exception:
        return []

# =============================================================================
# PARSING
# =============================================================================

def parse_temp_range(question: str) -> tuple:
    if not question:
        return None
    if "or below" in question.lower():
        m = re.search(r'(\d+)°F or below', question, re.IGNORECASE)
        if m: return (-999, int(m.group(1)))
    if "or higher" in question.lower():
        m = re.search(r'(\d+)°F or higher', question, re.IGNORECASE)
        if m: return (int(m.group(1)), 999)
    m = re.search(r'between (\d+)-(\d+)°F', question, re.IGNORECASE)
    if m: return (int(m.group(1)), int(m.group(2)))
    return None

def hours_until_resolution(event: dict) -> float:
    try:
        end_date = event.get("endDate") or event.get("end_date_iso")
        if not end_date: return 999
        end_dt = datetime.fromisoformat(end_date.replace("Z", "+00:00"))
        delta = (end_dt - datetime.now(timezone.utc)).total_seconds() / 3600
        return max(0, delta)
    except Exception:
        return 999

def detect_price_drop(history: list) -> dict:
    if not history or len(history) < 2:
        return {"dropped": False, "change": 0}
    recent = history[-1].get("p", 0.5)
    lookback = min(96, len(history) - 1)
    old = history[-lookback].get("p", recent)
    if old == 0: return {"dropped": False, "change": 0}
    change = (recent - old) / old
    return {"dropped": change < -PRICE_DROP_SIGNAL, "change": change}

# =============================================================================
# SHOW POSITIONS
# =============================================================================

def show_positions():
    sim = load_sim()
    positions = sim["positions"]
    print(f"\n{C.BOLD}📊 Open Positions:{C.RESET}")
    if not positions:
        print("  No open positions")
        return

    total_pnl = 0
    for mid, pos in positions.items():
        try:
            url = f"https://gamma-api.polymarket.com/markets/{mid}"
            r = requests.get(url, timeout=5)
            prices = json.loads(r.json().get("outcomePrices", "[0.5,0.5]"))
            current_price = float(prices[0])
        except Exception:
            current_price = pos["entry_price"]

        pnl = (current_price - pos["entry_price"]) * pos["shares"]
        total_pnl += pnl
        pnl_str = f"{C.GREEN}+${pnl:.2f}{C.RESET}" if pnl >= 0 else f"{C.RED}-${abs(pnl):.2f}{C.RESET}"
        print(f"\n  • {pos['question'][:65]}...")
        print(f"    Entry: ${pos['entry_price']:.3f} | Now: ${current_price:.3f} | "
              f"Shares: {pos['shares']:.1f} | PnL: {pnl_str}")
        print(f"    Kelly used: {pos.get('kelly_pct', 0):.1%} | EV: {pos.get('ev', 0):.2f} | Cost: ${pos['cost']:.2f}")

    print(f"\n  Balance:      ${sim['balance']:.2f}")
    pnl_color = C.GREEN if total_pnl >= 0 else C.RED
    print(f"  Open PnL:     {pnl_color}{'+'if total_pnl>=0 else ''}{total_pnl:.2f}{C.RESET}")
    print(f"  Total trades: {sim['total_trades']} | W/L: {sim['wins']}/{sim['losses']}")

# =============================================================================
# MAIN STRATEGY
# =============================================================================

def run(dry_run: bool = True):
    print(f"\n{C.BOLD}{C.CYAN}🌤  Weather Trading Bot v2 — Kelly + EV Edition{C.RESET}")
    print("=" * 55)

    sim = load_sim()
    balance = sim["balance"]
    positions = sim["positions"]

    mode = f"{C.YELLOW}PAPER MODE{C.RESET}" if dry_run else f"{C.GREEN}LIVE MODE{C.RESET}"
    starting = sim["starting_balance"]
    total_return = (balance - starting) / starting * 100
    return_str = f"{C.GREEN}+{total_return:.1f}%{C.RESET}" if total_return >= 0 else f"{C.RED}{total_return:.1f}%{C.RESET}"

    print(f"\n  Mode:            {mode}")
    print(f"  Virtual balance: {C.BOLD}${balance:.2f}{C.RESET} (started ${starting:.2f}, {return_str})")
    print(f"  Kelly fraction:  {KELLY_FRACTION:.0%} of full Kelly")
    print(f"  Max per trade:   {MAX_POSITION_PCT:.0%} of balance")
    print(f"  Min EV:          {MIN_EV:.2f} per $1 risked")
    print(f"  NOAA accuracy:   {NOAA_ACCURACY:.0%}")
    print(f"  Trades W/L:      {sim['wins']}/{sim['losses']}")

    forecast_cache = {}
    trades_executed = 0
    opportunities = 0

    # Check exits
    print(f"\n{C.BOLD}📤 Checking exits...{C.RESET}")
    exits_found = 0
    for mid, pos in list(positions.items()):
        try:
            url = f"https://gamma-api.polymarket.com/markets/{mid}"
            r = requests.get(url, timeout=5)
            prices = json.loads(r.json().get("outcomePrices", "[0.5,0.5]"))
            current_price = float(prices[0])
        except Exception:
            continue

        if current_price >= EXIT_THRESHOLD:
            exits_found += 1
            pnl = (current_price - pos["entry_price"]) * pos["shares"]
            ok(f"EXIT: {pos['question'][:50]}...")
            info(f"Price ${current_price:.3f} >= exit ${EXIT_THRESHOLD:.2f} | PnL: +${pnl:.2f}")

            if not dry_run:
                balance += pos["cost"] + pnl
                sim["wins"] += 1 if pnl > 0 else 0
                sim["losses"] += 1 if pnl <= 0 else 0
                sim["trades"].append({
                    "type": "exit", "question": pos["question"],
                    "entry_price": pos["entry_price"], "exit_price": current_price,
                    "pnl": round(pnl, 2), "cost": pos["cost"],
                    "closed_at": datetime.now().isoformat(),
                })
                del positions[mid]
                ok(f"Closed — PnL: {'+'if pnl>=0 else ''}{pnl:.2f}")
            else:
                skip("Paper mode — not selling")

    if exits_found == 0:
        skip("No exit opportunities")

    # Scan entries
    print(f"\n{C.BOLD}🔍 Scanning for entry signals...{C.RESET}")

    for city_slug in ACTIVE_LOCATIONS:
        if city_slug not in LOCATIONS:
            warn(f"Unknown location: {city_slug}")
            continue

        loc_data = LOCATIONS[city_slug]

        if city_slug not in forecast_cache:
            forecast_cache[city_slug] = get_forecast(city_slug)

        forecast = forecast_cache[city_slug]
        if not forecast:
            continue

        for i in range(0, 4):
            date = datetime.now() + timedelta(days=i)
            date_str = date.strftime("%Y-%m-%d")
            month = MONTHS[date.month - 1]
            day = date.day
            year = date.year

            forecast_temp = forecast.get(date_str)
            if forecast_temp is None:
                continue

            event = get_polymarket_event(city_slug, month, day, year)
            if not event:
                continue

            hours_left = hours_until_resolution(event)

            print(f"\n{C.BOLD}📍 {loc_data['name']} — {date_str}{C.RESET}")
            info(f"Forecast: {forecast_temp}°F | Resolves in: {hours_left:.0f}h")

            if hours_left < MIN_HOURS_LEFT:
                skip(f"Resolves in {hours_left:.0f}h — too soon")
                continue

            matched = None
            for market in event.get("markets", []):
                question = market.get("question", "")
                rng = parse_temp_range(question)
                if rng and rng[0] <= forecast_temp <= rng[1]:
                    try:
                        prices = json.loads(market.get("outcomePrices", "[0.5,0.5]"))
                        yes_price = float(prices[0])
                    except Exception:
                        continue
                    matched = {"market": market, "question": question,
                               "price": yes_price, "range": rng}
                    break

            if not matched:
                skip(f"No bucket found for {forecast_temp}°F")
                continue

            price = matched["price"]
            market_id = matched["market"].get("id", "")
            question = matched["question"]

            info(f"Bucket: {question[:60]}")
            info(f"Market price: ${price:.3f}")

            # Trend check
            history = get_price_history(market_id)
            trend = detect_price_drop(history)
            if trend["dropped"]:
                info(f"📉 Price dropped {abs(trend['change']):.0%} in 24h — stronger signal")

            # Kelly + EV
            our_prob = NOAA_ACCURACY
            if trend["dropped"] and abs(trend["change"]) > 0.20:
                our_prob = min(0.90, our_prob + 0.05)

            ev = calculate_ev(our_prob, price)
            kelly_pct = calculate_kelly(our_prob, price)
            position_size = calculate_position_size(kelly_pct, balance)

            print(f"\n  {C.BOLD}📐 Kelly + EV Analysis:{C.RESET}")
            info(f"  Our probability:  {our_prob:.0%}")
            info(f"  Market implies:   {price:.1%}")
            info(f"  Edge:             {our_prob - price:.1%}")

            ev_color = C.GREEN if ev > 0 else C.RED
            print(f"  {C.CYAN}  EV per $1:        {ev_color}{ev:+.2f}{C.RESET}")
            print(f"  {C.CYAN}  Kelly fraction:   {kelly_pct:.1%} of balance{C.RESET}")
            print(f"  {C.CYAN}  Position size:    ${position_size:.2f}{C.RESET}")

            if price >= ENTRY_THRESHOLD:
                skip(f"Price ${price:.3f} above threshold ${ENTRY_THRESHOLD:.2f}")
                continue

            if ev < MIN_EV:
                skip(f"EV {ev:.2f} below minimum {MIN_EV:.2f} — skip")
                continue

            if kelly_pct <= 0:
                skip("Kelly says no edge — skip")
                continue

            opportunities += 1
            ok(f"ENTRY signal! EV={ev:+.2f} | Kelly={kelly_pct:.1%} | Size=${position_size:.2f}")

            if market_id in positions:
                skip("Already in this market")
                continue

            if trades_executed >= MAX_TRADES:
                skip(f"Max trades ({MAX_TRADES}) reached")
                continue

            if position_size < 0.50:
                skip(f"Position size ${position_size:.2f} too small — skip")
                continue

            shares = position_size / price
            info(f"Buying {shares:.1f} shares @ ${price:.3f} = ${position_size:.2f}")

            if not dry_run:
                balance -= position_size
                positions[market_id] = {
                    "question": question,
                    "entry_price": price,
                    "shares": shares,
                    "cost": position_size,
                    "kelly_pct": kelly_pct,
                    "ev": ev,
                    "our_prob": our_prob,
                    "date": date_str,
                    "location": city_slug,
                    "forecast_temp": forecast_temp,
                    "opened_at": datetime.now().isoformat(),
                }
                sim["total_trades"] += 1
                sim["trades"].append({
                    "type": "entry", "question": question,
                    "entry_price": price, "shares": shares,
                    "cost": position_size, "kelly_pct": kelly_pct,
                    "ev": ev, "our_prob": our_prob,
                    "opened_at": datetime.now().isoformat(),
                })
                trades_executed += 1
                ok(f"Bought {shares:.1f} shares — ${position_size:.2f} deducted from balance")
            else:
                skip("Paper mode — not buying")
                trades_executed += 1

    if not dry_run:
        sim["balance"] = round(balance, 2)
        sim["positions"] = positions
        sim["peak_balance"] = max(sim["peak_balance"], balance)
        save_sim(sim)

    print(f"\n{'=' * 55}")
    print(f"{C.BOLD}📊 Summary:{C.RESET}")
    info(f"Opportunities found: {opportunities}")
    info(f"Trades executed:     {trades_executed}")
    info(f"Exits found:         {exits_found}")
    info(f"Balance:             ${balance:.2f}")

    if dry_run:
        print(f"\n  {C.YELLOW}[PAPER MODE — use --live to simulate trades against real prices]{C.RESET}")

# =============================================================================
# LIVE MONITOR
# =============================================================================

import time as _time

def monitor(interval: int = 10):
    """
    Background monitor — fetches live prices every N seconds,
    updates simulation.json so the dashboard stays current.
    Auto-exits positions when price hits EXIT_THRESHOLD.
    """
    print(f"\n{C.BOLD}{C.CYAN}📡 Live Monitor — refreshing every {interval}s{C.RESET}")
    print(f"  Auto-exit threshold: ${EXIT_THRESHOLD:.2f}")
    print(f"  Press Ctrl+C to stop\n")

    while True:
        try:
            sim = load_sim()
            positions = sim.get("positions", {})

            if not positions:
                print(f"{C.GRAY}  {_time.strftime('%H:%M:%S')} — No open positions{C.RESET}")
                _time.sleep(interval)
                continue

            total_pnl = 0

            for mid, pos in list(positions.items()):
                try:
                    url = f"https://gamma-api.polymarket.com/markets/{mid}"
                    r = requests.get(url, timeout=5)
                    data = r.json()
                    prices = json.loads(data.get("outcomePrices", "[0.5,0.5]"))
                    current_price = float(prices[0])
                except Exception:
                    current_price = pos.get("current_price", pos["entry_price"])

                pnl = (current_price - pos["entry_price"]) * pos["shares"]
                pos["current_price"] = round(current_price, 4)
                pos["pnl"] = round(pnl, 2)
                total_pnl += pnl

                pnl_str = f"{C.GREEN}+${pnl:.2f}{C.RESET}" if pnl >= 0 else f"{C.RED}-${abs(pnl):.2f}{C.RESET}"
                print(f"  {C.GRAY}{_time.strftime('%H:%M:%S')}{C.RESET}  "
                      f"{pos['question'][:45]}...  "
                      f"${current_price:.3f}  {pnl_str}")

                if current_price >= EXIT_THRESHOLD:
                    ok(f"AUTO EXIT: {pos['question'][:50]}... PnL: +${pnl:.2f}")
                    sim["balance"] = round(sim["balance"] + pos["cost"] + pnl, 2)
                    sim["wins"] += 1 if pnl > 0 else 0
                    sim["losses"] += 1 if pnl <= 0 else 0
                    sim["trades"].append({
                        "type": "exit",
                        "question": pos["question"],
                        "entry_price": pos["entry_price"],
                        "exit_price": current_price,
                        "pnl": round(pnl, 2),
                        "cost": pos["cost"],
                        "kelly_pct": pos.get("kelly_pct", 0),
                        "ev": pos.get("ev", 0),
                        "closed_at": datetime.now().isoformat(),
                    })
                    del sim["positions"][mid]

            sim["peak_balance"] = max(sim.get("peak_balance", sim["balance"]), sim["balance"])

            total_str = f"{C.GREEN}+${total_pnl:.2f}{C.RESET}" if total_pnl >= 0 else f"{C.RED}-${abs(total_pnl):.2f}{C.RESET}"
            print(f"  {'─'*60}")
            print(f"  Open PnL: {total_str}  |  Balance: ${sim['balance']:.2f}  |  "
                  f"Positions: {len(sim['positions'])}\n")

            save_sim(sim)

        except KeyboardInterrupt:
            print(f"\n{C.YELLOW}  Monitor stopped{C.RESET}")
            break
        except Exception as e:
            warn(f"Monitor error: {e}")

        _time.sleep(interval)

# =============================================================================
# CLI
# =============================================================================

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Weather Trading Bot v2 — Kelly + EV")
    parser.add_argument("--live", action="store_true", help="Execute trades (updates simulation balance)")
    parser.add_argument("--positions", action="store_true", help="Show open positions")
    parser.add_argument("--reset", action="store_true", help="Reset simulation to $1000")
    parser.add_argument("--monitor", action="store_true", help="Live price monitor")
    parser.add_argument("--interval", type=int, default=10, help="Monitor refresh interval in seconds")
    args = parser.parse_args()

    if args.reset:
        reset_sim()
    elif args.positions:
        show_positions()
    elif args.monitor:
        monitor(interval=args.interval)
    else:
        run(dry_run=not args.live)