Upload cboe_adapter.py with huggingface_hub

cboe_adapter.py

@@ -1,27 +1,407 @@
 """
-Lightweight CBOE adapter: attempts to fetch options chain JSON from CBOE CDN and normalize into DataFrames.
-Falls back to None in demo mode.
+CBOE Adapter Module
+===================
+Fetches and normalizes options chain data from CBOE delayed quotes API.
+
+Supports:
+  - SPX (S&P 500 Index options)
+  - VIX (Volatility Index options)
+  - Other CBOE-listed index options
+
+Functions:
+  - fetch_cboe_chain: Fetch raw CBOE options chain
+  - parse_cboe_chain: Parse raw JSON into normalized DataFrames
+  - fetch_spx_chain: Convenience function for SPX
+  - fetch_vix_chain: Convenience function for VIX
+  - get_spot_price: Get current spot price from CBOE
 """
+
 import requests
 import pandas as pd
+import numpy as np
 import os
+import logging
+from typing import Optional, Dict, Any, List, Tuple
+from datetime import datetime, timedelta
+
+logger = logging.getLogger("mk_quant.cboe")
+
+CBOE_BASE_URL = "https://cdn.cboe.com/api/global/delayed_quotes/options"
+
+# Map of supported symbols to their CBOE API identifiers
+CBOE_SYMBOLS = {
+    "SPX": "SPX",
+    "VIX": "VIX",
+    "NDX": "NDX",
+    "RUT": "RUT",
+    "DJX": "DJX",
+    "SPY": "SPY",
+    "QQQ": "QQQ",
+}
 
-CBOE_CDN = 'https://cdn.cboe.com/api/global/delayed_quotes/options'  # placeholder
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
+    "Accept": "application/json",
+}
 
 
-def fetch_options_chain(symbol):
-    """Return (calls_df, puts_df, expiries) or None on failure."""
+def fetch_cboe_chain(symbol: str) -> Optional[Dict[str, Any]]:
+    """
+    Fetch raw options chain from CBOE delayed quotes API.
+    
+    Parameters
+    ----------
+    symbol : CBOE symbol (e.g., 'SPX', 'VIX')
+    
+    Returns
+    -------
+    Raw JSON response dict or None on failure
+    """
+    cboe_symbol = CBOE_SYMBOLS.get(symbol.upper(), symbol.upper())
+    url = f"{CBOE_BASE_URL}/{cboe_symbol}.json"
+    
+    demo_mode = os.environ.get("DEMO_MODE", "0") == "1"
+    if demo_mode:
+        logger.info(f"DEMO_MODE: Skipping CBOE fetch for {symbol}")
+        return None
+    
     try:
-        # This is a placeholder fetch - real endpoint and parsing required
-        if os.environ.get('DEMO_MODE','1')=='1':
+        r = requests.get(url, headers=HEADERS, timeout=15)
+        r.raise_for_status()
+        data = r.json()
+        
+        if "data" not in data:
+            logger.warning(f"CBOE response missing 'data' key for {symbol}")
             return None
-        url = f"{CBOE_CDN}/{symbol}.json"
-        r = requests.get(url, timeout=8)
-        j = r.json()
-        # Parse into calls, puts - simplified
-        calls = pd.DataFrame(j.get('calls', []))
-        puts = pd.DataFrame(j.get('puts', []))
-        expiries = sorted(j.get('expirations', []))
-        return calls, puts, expiries
-    except Exception:
+        
+        return data
+    
+    except requests.exceptions.Timeout:
+        logger.warning(f"CBOE timeout for {symbol}")
+    except requests.exceptions.HTTPError as e:
+        logger.warning(f"CBOE HTTP error for {symbol}: {e}")
+    except Exception as e:
+        logger.warning(f"CBOE fetch error for {symbol}: {e}")
+    
+    return None
+
+
+def parse_cboe_chain(raw_data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Parse raw CBOE JSON into normalized format.
+    
+    Returns dict with:
+      - spot: Current spot price
+      - records: List of strike records with keys:
+          strike, expiry, option_type, iv, delta, gamma, theta, vega,
+          open_interest, bid, ask, last
+      - calls_df: DataFrame of call options
+      - puts_df: DataFrame of put options
+      - expirations: Sorted list of expiration dates
+      - timestamp: Fetch timestamp
+    """
+    if not raw_data or "data" not in raw_data:
+        return {"spot": 0, "records": [], "calls_df": pd.DataFrame(),
+                "puts_df": pd.DataFrame(), "expirations": [], "timestamp": ""}
+    
+    data = raw_data["data"]
+    spot = float(data.get("current_price", 0))
+    options = data.get("options", [])
+    timestamp = datetime.utcnow().isoformat()
+    
+    if not options:
+        return {"spot": spot, "records": [], "calls_df": pd.DataFrame(),
+                "puts_df": pd.DataFrame(), "expirations": [], "timestamp": timestamp}
+    
+    # Parse all options into records
+    records = []
+    calls_records = []
+    puts_records = []
+    
+    for opt in options:
+        try:
+            strike = float(opt.get("strike", 0))
+            if strike <= 0:
+                continue
+            
+            expiry = str(opt.get("expiration", ""))
+            otype = str(opt.get("option_type", "")).upper()
+            
+            record = {
+                "strike": strike,
+                "expiry": expiry,
+                "option_type": otype,
+                "iv": float(opt.get("iv", 0) or 0),
+                "delta": float(opt.get("delta", 0) or 0),
+                "gamma": float(opt.get("gamma", 0) or 0),
+                "theta": float(opt.get("theta", 0) or 0),
+                "vega": float(opt.get("vega", 0) or 0),
+                "open_interest": int(opt.get("open_interest", 0) or 0),
+                "bid": float(opt.get("bid", 0) or 0),
+                "ask": float(opt.get("ask", 0) or 0),
+                "last": float(opt.get("last_price", 0) or 0),
+                "volume": int(opt.get("volume", 0) or 0),
+            }
+            
+            records.append(record)
+            
+            if otype == "C":
+                calls_records.append(record)
+            elif otype == "P":
+                puts_records.append(record)
+                
+        except (ValueError, TypeError) as e:
+            logger.debug(f"Skipping malformed option record: {e}")
+            continue
+    
+    calls_df = pd.DataFrame(calls_records) if calls_records else pd.DataFrame()
+    puts_df = pd.DataFrame(puts_records) if puts_records else pd.DataFrame()
+    
+    # Get unique expirations sorted
+    expirations = sorted(set(r["expiry"] for r in records if r["expiry"]))
+    
+    return {
+        "spot": spot,
+        "records": records,
+        "calls_df": calls_df,
+        "puts_df": puts_df,
+        "expirations": expirations,
+        "timestamp": timestamp,
+        "source": "cboe_live",
+    }
+
+
+def fetch_spx_chain() -> Optional[Dict[str, Any]]:
+    """
+    Fetch SPX options chain from CBOE.
+    
+    Returns parsed chain dict or None on failure.
+    """
+    raw = fetch_cboe_chain("SPX")
+    if raw is None:
         return None
+    return parse_cboe_chain(raw)
+
+
+def fetch_vix_chain() -> Optional[Dict[str, Any]]:
+    """
+    Fetch VIX options chain from CBOE.
+    
+    Returns parsed chain dict or None on failure.
+    """
+    raw = fetch_cboe_chain("VIX")
+    if raw is None:
+        return None
+    return parse_cboe_chain(raw)
+
+
+def get_spot_price(symbol: str) -> Optional[float]:
+    """
+    Get current spot price for a CBOE-listed symbol.
+    
+    Returns float price or None on failure.
+    """
+    raw = fetch_cboe_chain(symbol)
+    if raw and "data" in raw:
+        return float(raw["data"].get("current_price", 0))
+    return None
+
+
+def fetch_cboe_multi_expiry(symbol: str, max_expiries: int = 6) -> Dict[str, Any]:
+    """
+    Fetch options chain and organize by expiry.
+    
+    Returns dict with:
+      - spot: Current spot price
+      - by_expiry: Dict mapping expiry -> {calls_df, puts_df, records}
+      - all_records: All records combined
+      - expirations: List of expirations
+    """
+    chain = fetch_cboe_chain(symbol)
+    if chain is None:
+        return {"spot": 0, "by_expiry": {}, "all_records": [], "expirations": []}
+    
+    parsed = parse_cboe_chain(chain)
+    
+    by_expiry = {}
+    for exp in parsed["expirations"][:max_expiries]:
+        exp_records = [r for r in parsed["records"] if r["expiry"] == exp]
+        exp_calls = [r for r in exp_records if r["option_type"] == "C"]
+        exp_puts = [r for r in exp_records if r["option_type"] == "P"]
+        
+        by_expiry[exp] = {
+            "records": exp_records,
+            "calls_df": pd.DataFrame(exp_calls) if exp_calls else pd.DataFrame(),
+            "puts_df": pd.DataFrame(exp_puts) if exp_puts else pd.DataFrame(),
+        }
+    
+    return {
+        "spot": parsed["spot"],
+        "by_expiry": by_expiry,
+        "all_records": parsed["records"],
+        "expirations": parsed["expirations"][:max_expiries],
+        "timestamp": parsed["timestamp"],
+    }
+
+
+def generate_synthetic_chain(
+    spot: float = 6632.0,
+    n_strikes: int = 48,
+    strike_step: int = 25,
+    expiries: List[str] = None,
+) -> Dict[str, Any]:
+    """
+    Generate synthetic options chain for demo/testing.
+    
+    Creates realistic-looking options data with proper skew and gamma profile.
+    """
+    rng = np.random.default_rng(42)
+    
+    if expiries is None:
+        # Generate 4 weekly + 2 monthly expiries
+        today = datetime.utcnow().date()
+        expiries = []
+        for i in range(1, 5):
+            d = today + timedelta(weeks=i)
+            expiries.append(d.strftime("%Y-%m-%d"))
+        for i in range(1, 3):
+            d = today + timedelta(days=30*i)
+            expiries.append(d.strftime("%Y-%m-%d"))
+    
+    center = spot
+    strikes = np.arange(center - (n_strikes//2)*strike_step,
+                        center + (n_strikes//2)*strike_step + 1,
+                        strike_step)
+    
+    all_records = []
+    
+    for exp in expiries:
+        try:
+            exp_date = datetime.strptime(exp, "%Y-%m-%d").date()
+            dte = max(1, (exp_date - datetime.utcnow().date()).days)
+        except:
+            dte = 30
+        
+        T = dte / 365.0
+        
+        for strike in strikes:
+            atm_dist = (strike - spot) / spot
+            
+            # Realistic IV skew
+            base_iv = 0.18 + abs(atm_dist) * 0.3 - atm_dist * 0.05
+            iv_call = max(0.05, base_iv + rng.normal(0, 0.005))
+            iv_put = max(0.05, iv_call + 0.01 + max(0.0, -atm_dist * 0.08) + rng.normal(0, 0.005))
+            
+            # Gamma profile (peaks ATM, decays with distance)
+            gamma_base = 0.003 * np.exp(-50 * atm_dist**2)
+            gamma_call = max(0.00001, gamma_base * (1 + rng.normal(0, 0.1)))
+            gamma_put = max(0.00001, gamma_base * (1 + rng.normal(0, 0.1)))
+            
+            # Delta
+            if T > 0 and iv_call > 0:
+                d1 = (np.log(spot/strike) + (0.5 * iv_call**2) * T) / (iv_call * np.sqrt(T))
+                delta_call = float(max(0.01, min(0.99, 0.5 + d1 * 0.4)))
+            else:
+                delta_call = 0.5
+            
+            if T > 0 and iv_put > 0:
+                d1 = (np.log(spot/strike) + (0.5 * iv_put**2) * T) / (iv_put * np.sqrt(T))
+                delta_put = float(max(-0.99, min(-0.01, -0.5 + d1 * 0.4)))
+            else:
+                delta_put = -0.5
+            
+            # OI (higher ATM, lower wings)
+            oi_base = abs(rng.normal(8000, 3000))
+            oi_factor = np.exp(-30 * atm_dist**2) + 0.1
+            oi_call = int(oi_base * oi_factor)
+            oi_put = int(oi_base * oi_factor * 1.2)  # Slightly more put OI
+            
+            # Theta
+            theta_call = -gamma_call * spot * spot * iv_call / (2 * np.sqrt(T)) / 365 if T > 0 else 0
+            theta_put = -gamma_put * spot * spot * iv_put / (2 * np.sqrt(T)) / 365 if T > 0 else 0
+            
+            # Vega
+            vega_val = spot * np.sqrt(T) * np.exp(-0.5 * ((np.log(spot/strike)/iv_call)**2 if iv_call > 0 else 0)) * 0.01 if T > 0 and iv_call > 0 else 0
+            
+            # Vanna
+            vanna_val = -gamma_call * (1 - delta_call) / iv_call if iv_call > 0 else 0
+            
+            # Bid/ask (synthetic spread)
+            intrinsic_c = max(0, spot - strike)
+            time_value_c = max(0.01, iv_call * spot * np.sqrt(T) * 0.4)
+            mid_c = intrinsic_c + time_value_c
+            spread_c = max(0.1, mid_c * 0.02)
+            
+            intrinsic_p = max(0, strike - spot)
+            time_value_p = max(0.01, iv_put * spot * np.sqrt(T) * 0.4)
+            mid_p = intrinsic_p + time_value_p
+            spread_p = max(0.1, mid_p * 0.02)
+            
+            # Call record
+            all_records.append({
+                "strike": float(strike),
+                "expiry": exp,
+                "option_type": "C",
+                "iv": round(iv_call, 4),
+                "delta": round(delta_call, 4),
+                "gamma": round(gamma_call, 6),
+                "theta": round(theta_call, 4),
+                "vega": round(vega_val, 4),
+                "vanna": round(vanna_val, 4),
+                "open_interest": oi_call,
+                "bid": round(max(0.01, mid_c - spread_c/2), 2),
+                "ask": round(mid_c + spread_c/2, 2),
+                "last": round(mid_c, 2),
+                "volume": int(abs(rng.normal(1000, 500))),
+            })
+            
+            # Put record
+            all_records.append({
+                "strike": float(strike),
+                "expiry": exp,
+                "option_type": "P",
+                "iv": round(iv_put, 4),
+                "delta": round(delta_put, 4),
+                "gamma": round(gamma_put, 6),
+                "theta": round(theta_put, 4),
+                "vega": round(vega_val, 4),
+                "vanna": round(vanna_val, 4),
+                "open_interest": oi_put,
+                "bid": round(max(0.01, mid_p - spread_p/2), 2),
+                "ask": round(mid_p + spread_p/2, 2),
+                "last": round(mid_p, 2),
+                "volume": int(abs(rng.normal(1000, 500))),
+            })
+    
+    calls_df = pd.DataFrame([r for r in all_records if r["option_type"] == "C"])
+    puts_df = pd.DataFrame([r for r in all_records if r["option_type"] == "P"])
+    
+    return {
+        "spot": spot,
+        "records": all_records,
+        "calls_df": calls_df,
+        "puts_df": puts_df,
+        "expirations": expiries,
+        "timestamp": datetime.utcnow().isoformat(),
+        "source": "synthetic",
+    }
+
+
+if __name__ == "__main__":
+    # Test live fetch
+    print("Testing CBOE SPX chain fetch...")
+    chain = fetch_spx_chain()
+    
+    if chain:
+        print(f"Spot: {chain['spot']}")
+        print(f"Records: {len(chain['records'])}")
+        print(f"Expirations: {chain['expirations'][:5]}")
+        if not chain['calls_df'].empty:
+            print(f"Calls columns: {list(chain['calls_df'].columns)}")
+            print(chain['calls_df'].head(3).to_string())
+    else:
+        print("Live fetch failed, generating synthetic chain...")
+        synth = generate_synthetic_chain()
+        print(f"Synthetic spot: {synth['spot']}")
+        print(f"Synthetic records: {len(synth['records'])}")
+        print(f"Synthetic expirations: {synth['expirations']}")