Data Sources

def get_risk_free_rate(self) -> float:
    """
    Obtiene la Tasa Libre de Riesgo usando el bono a 3 meses (^IRX).
    Retorna float (ej: 0.052 para 5.2%).
    """
    try:
        # ^IRX is the 13-week T-Bill yield index
        t = yf.Ticker("^IRX")
        
        # Try fast_info first
        rate = t.fast_info.last_price
        if rate is None or str(rate) == 'nan':
            hist = t.history(period='1d')
            if not hist.empty:
                rate = hist['Close'].iloc[-1]
            else:
                return 0.05  # Fallback 5%
        
        # Value comes as percentage (e.g., 4.5), convert to decimal
        return float(rate) / 100.0
        
    except Exception as e:
        logger.warning(f"Could not get risk-free rate, using 5%: {e}")
        return 0.05

class OptionsDataManager:
    """
    Gestor de datos de Opciones (YFinance + Alpha Vantage).
    Encargado de descargar cadenas de opciones, precios spot y 
    manejar Rate Limits.
    """
    
    def __init__(self, delay: float = 1.5):
        self.delay = delay
        self.av_api_key = os.getenv("ALPHA_VANTAGE_KEY")
        self.av_client = AVOptions(key=self.av_api_key) if (
            self.av_api_key and AVOptions) else None
        
        if not self.av_client:
            logger.warning("Alpha Vantage not configured. Using YFinance only.")

def _safe_request(self, func, *args, **kwargs):
    """Envoltorio para manejar Rate Limits y pausas."""
    time.sleep(self.delay)
    try:
        return func(*args, **kwargs)
    except Exception as e:
        msg = str(e)
        if "Too Many Requests" in msg or "429" in msg:
            logger.critical(f"RATE LIMIT (429) detected. Stopping execution.")
            raise ConnectionError("RATE_LIMIT_HIT")
        logger.error(f"Error in yfinance request: {e}")
        raise e

# Get spot price and risk-free rate
spot = self.get_spot_price(ticker)
r = self.get_risk_free_rate()  # Dynamic from ^IRX

# FORCE CALCULATION: yfinance Greeks are often bad/incomplete
need_calc = True

if need_calc:
    deltas, gammas, thetas, vegas = [], [], [], []
    
    for idx, row in df.iterrows():
        try:
            T_years = max(row['dte'], 0.5) / 365.0  # Min 0.5 days
            sigma = row['impliedVolatility']
            
            if sigma <= 0 or T_years <= 0:
                # Invalid parameters
                deltas.append(0.0); gammas.append(0.0)
                thetas.append(0.0); vegas.append(0.0)
                continue
            
            # Calculate Greeks using our BSM implementation
            greeks = bsm_greeks(
                S=spot, 
                K=row['strike'], 
                T=T_years, 
                r=r,  # Current risk-free rate
                sigma=sigma,  # Market implied vol
                q=0.0,  # Dividend yield (set to 0 for simplicity)
                kind=row['type']
            )
            
            deltas.append(greeks.get('delta', 0.0))
            gammas.append(greeks.get('gamma', 0.0))
            thetas.append(greeks.get('theta', 0.0))
            vegas.append(greeks.get('vega', 0.0))
        except Exception:
            deltas.append(0.0); gammas.append(0.0)
            thetas.append(0.0); vegas.append(0.0)
    
    # Update dataframe
    df['delta'] = deltas
    df['gamma'] = gammas
    df['theta'] = thetas
    df['vega'] = vegas

from app.data.data_manager import OptionsDataManager

manager = OptionsDataManager()
hv_stats = manager.get_historical_volatility("SPY")

print(f"Current 30-day HV: {hv_stats['current_hv']*100:.2f}%")
print(f"1-Year Mean HV:    {hv_stats['mean_hv']*100:.2f}%")
print(f"HV Range:          {hv_stats['min_hv']*100:.2f}% - {hv_stats['max_hv']*100:.2f}%")
print(f"Current Percentile: {hv_stats['percentile']:.1f}th")

# Output:
# Current 30-day HV: 18.45%
# 1-Year Mean HV:    20.12%
# HV Range:          12.34% - 35.67%
# Current Percentile: 42.3rd

def get_spot_price(self, ticker: str) -> float:
    """Obtiene el precio actual del activo subyacente."""
    try:
        t = yf.Ticker(ticker)
        
        # Try fast_info first (faster)
        price = t.fast_info.last_price
        if price is None:
            # Fallback to history
            history = t.history(period="1d")
            if not history.empty:
                price = history["Close"].iloc[-1]
        
        return price
    except Exception as e:
        logger.error(f"Could not get spot price for {ticker}: {e}")
        return 0.0

# Router: backend/app/api/routers/option_chains.py

@router.get("/options/expirations/{ticker}")
async def get_expirations(ticker: str):
    """
    Returns list of available expiration dates and current spot price.
    
    Response:
    {
        "ticker": "SPY",
        "spot_price": 450.23,
        "risk_free_rate": 0.0512,
        "expirations": ["2024-01-19", "2024-02-16", ...]
    }
    """
    manager = OptionsDataManager()
    
    # Get ticker info
    t = yf.Ticker(ticker)
    spot = manager.get_spot_price(ticker)
    rfr = manager.get_risk_free_rate()
    expirations = list(t.options)
    
    return {
        "ticker": ticker.upper(),
        "spot_price": spot,
        "risk_free_rate": rfr,
        "expirations": expirations
    }

@router.get("/options/chain/{ticker}")
async def get_option_chain(ticker: str, expiration: str = None, 
                          min_days: int = 20, max_days: int = 60):
    """
    Returns option chain for specified expiration or date range.
    
    Query Parameters:
    - expiration: Specific date (YYYY-MM-DD) or None for range
    - min_days: Minimum DTE (default: 20)
    - max_days: Maximum DTE (default: 60)
    
    Response:
    {
        "spot_price": 450.23,
        "chain": {
            "calls": [{strike, bid, ask, iv, delta, ...}, ...],
            "puts": [{strike, bid, ask, iv, delta, ...}, ...]
        }
    }
    """
    manager = OptionsDataManager()
    
    if expiration:
        # Specific expiration
        df = manager.get_full_option_chain(ticker, min_days=0, max_days=9999)
        df = df[df['expirationDate'] == pd.to_datetime(expiration)]
    else:
        # Date range
        df = manager.get_full_option_chain(ticker, min_days, max_days)
    
    # Split into calls and puts
    calls = df[df['type'] == 'call'].to_dict('records')
    puts = df[df['type'] == 'put'].to_dict('records')
    
    return {
        "spot_price": manager.get_spot_price(ticker),
        "chain": {"calls": calls, "puts": puts}
    }

import redis
import json
from functools import wraps

redis_client = redis.Redis(host='localhost', port=6379, db=0)

def cache_spot_price(ttl=5):  # 5 seconds
    def decorator(func):
        @wraps(func)
        def wrapper(self, ticker):
            key = f"spot:{ticker}"
            cached = redis_client.get(key)
            
            if cached:
                return float(cached)
            
            result = func(self, ticker)
            redis_client.setex(key, ttl, str(result))
            return result
        return wrapper
    return decorator

def cache_risk_free_rate(ttl=3600):  # 1 hour
    def decorator(func):
        @wraps(func)
        def wrapper(self):
            key = "rfr:current"
            cached = redis_client.get(key)
            
            if cached:
                return float(cached)
            
            result = func(self)
            redis_client.setex(key, ttl, str(result))
            return result
        return wrapper
    return decorator

def cache_option_chain(ttl=60):  # 1 minute
    def decorator(func):
        @wraps(func)
        def wrapper(self, ticker, min_days, max_days):
            key = f"chain:{ticker}:{min_days}:{max_days}"
            cached = redis_client.get(key)
            
            if cached:
                df = pd.read_json(cached)
                return df
            
            result = func(self, ticker, min_days, max_days)
            redis_client.setex(key, ttl, result.to_json())
            return result
        return wrapper
    return decorator

# Usage:
class OptionsDataManager:
    @cache_spot_price(ttl=5)
    def get_spot_price(self, ticker: str) -> float:
        # ... implementation
        pass
    
    @cache_risk_free_rate(ttl=3600)
    def get_risk_free_rate(self) -> float:
        # ... implementation
        pass
    
    @cache_option_chain(ttl=60)
    def get_full_option_chain(self, ticker, min_days, max_days):
        # ... implementation
        pass

def get_option_data_with_fallback(ticker: str) -> pd.DataFrame:
    """Attempt multiple strategies before failing."""
    manager = OptionsDataManager()
    
    # Strategy 1: Try Alpha Vantage + YFinance hybrid
    try:
        df = manager.get_full_option_chain(ticker, min_days=20, max_days=60)
        if not df.empty:
            return df
    except ConnectionError as e:
        if "RATE_LIMIT_HIT" in str(e):
            logger.warning(f"Rate limit hit, waiting...")
            time.sleep(60)
            # Retry once
            try:
                df = manager.get_full_option_chain(ticker, min_days=20, max_days=60)
                if not df.empty:
                    return df
            except Exception:
                pass
    except Exception as e:
        logger.error(f"Primary strategy failed: {e}")
    
    # Strategy 2: Try wider date range
    try:
        logger.info("Trying wider date range...")
        df = manager.get_full_option_chain(ticker, min_days=1, max_days=90)
        if not df.empty:
            return df
    except Exception as e:
        logger.error(f"Wider range failed: {e}")
    
    # Strategy 3: Return empty with explanation
    logger.critical(f"All strategies failed for {ticker}")
    raise ValueError(f"Could not fetch option data for {ticker}. Try again later.")

import time

manager = OptionsDataManager(delay=1.5)

# Spot price fetch
start = time.time()
spot = manager.get_spot_price("SPY")
print(f"Spot price: {time.time() - start:.3f}s")
# Output: Spot price: 0.023s (fast_info)

# Risk-free rate fetch
start = time.time()
rfr = manager.get_risk_free_rate()
print(f"Risk-free rate: {time.time() - start:.3f}s")
# Output: Risk-free rate: 0.034s

# Option chain fetch (3 expirations, ~500 contracts)
start = time.time()
df = manager.get_full_option_chain("SPY", min_days=20, max_days=60)
print(f"Option chain: {time.time() - start:.3f}s ({len(df)} contracts)")
# Output: Option chain: 8.234s (512 contracts)
# Note: 3 expirations × 1.5s delay + download time