indicadores.py

# indicadores.py
# Módulo expandido de indicadores técnicos
# Conocimiento extraído de los manuales:
#  - "Manual Avanzado de Trading" (Admiral Markets)
#  - "Manual de Velas Japonesas" (Ustinpowuer)
#  - Tesis UNICEN sobre opciones binarias
#  - Teoría de Dow, Ondas de Elliot, Bandas de Bollinger, Fibonacci
#
# Incluye: EMAs, RSI, MACD, Bollinger, ATR, ADX, Estocástico, CCI, Williams %R,
# Momentum, ROC, Fibonacci (38.2/50/61.8), VWAP, OBV, y más.

import numpy as np
import pandas as pd


def calcular_todos_los_indicadores(df: pd.DataFrame) -> pd.DataFrame:
    """
    Calcula una batería completa de indicadores técnicos para alimentar la red
    neuronal profunda. Basado en el manual de Admiral Markets.
    """
    df = df.copy()
    c = df['close']
    h = df['high']
    l = df['low']
    vol = df['volume'] if 'volume' in df.columns else pd.Series(np.ones(len(c)))

    # ==== 1. MEDIAS MÓVILES (EMAs) ====
    for span in [9, 21, 50, 100, 200]:
        ema = c.ewm(span=span, adjust=False).mean()
        df[f'ema_{span}'] = ema
        df[f'dist_ema_{span}'] = (c - ema) / (ema + 1e-8)

    # ==== 2. RSI (Relative Strength Index) ====
    delta = c.diff()
    gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
    loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
    rs = gain / (loss + 1e-8)
    df['rsi'] = (100 - (100 / (1 + rs))) / 100.0  # 0 a 1
    df['rsi_7'] = _rsi(c, 7) / 100.0
    df['rsi_21'] = _rsi(c, 21) / 100.0

    # ==== 3. MACD ====
    ema12 = c.ewm(span=12, adjust=False).mean()
    ema26 = c.ewm(span=26, adjust=False).mean()
    df['macd'] = ema12 - ema26
    df['macd_signal'] = df['macd'].ewm(span=9, adjust=False).mean()
    df['macd_hist'] = df['macd'] - df['macd_signal']
    df['macd_hist_norm'] = df['macd_hist'] / (c + 1e-8)

    # ==== 4. BANDAS DE BOLLINGER (%B + ancho) ====
    sma20 = c.rolling(window=20).mean()
    std20 = c.rolling(window=20).std()
    bollinger_upper = sma20 + (std20 * 2)
    bollinger_lower = sma20 - (std20 * 2)
    df['bollinger_pct'] = (c - bollinger_lower) / (bollinger_upper - bollinger_lower + 1e-8)
    df['bollinger_width'] = (bollinger_upper - bollinger_lower) / (sma20 + 1e-8)

    # ==== 5. ATR (Average True Range) ====
    tr = np.maximum(h - l, np.maximum(np.abs(h - c.shift(1)), np.abs(l - c.shift(1))))
    df['atr'] = pd.Series(tr).rolling(window=14).mean() / (c + 1e-8)
    df['atr_7'] = pd.Series(tr).rolling(window=7).mean() / (c + 1e-8)

    # ==== 6. ESTOCÁSTICO (Stochastic Oscillator) ====
    low_14 = l.rolling(window=14).min()
    high_14 = h.rolling(window=14).max()
    df['stoch_k'] = ((c - low_14) / (high_14 - low_14 + 1e-8))
    df['stoch_d'] = df['stoch_k'].rolling(window=3).mean()

    # ==== 7. ADX (Average Directional Index) - fuerza de tendencia ====
    df['adx'] = _adx(h, l, c, 14)

    # ==== 8. WILLIAMS %R ====
    df['williams_r'] = ((high_14 - c) / (high_14 - low_14 + 1e-8)) * -1

    # ==== 9. CCI (Commodity Channel Index) ====
    tp = (h + l + c) / 3
    sma_tp = tp.rolling(window=20).mean()
    mad = tp.rolling(window=20).apply(lambda x: np.mean(np.abs(x - x.mean())), raw=True)
    df['cci'] = (tp - sma_tp) / (0.015 * mad + 1e-8)
    df['cci'] = df['cci'].clip(-300, 300) / 300.0  # normalizar a [-1, 1]

    # ==== 10. MOMENTUM / ROC ====
    df['momentum_10'] = (c - c.shift(10)) / (c.shift(10) + 1e-8)
    df['roc_12'] = (c - c.shift(12)) / (c.shift(12) + 1e-8)

    # ==== 11. FIBONACCI (niveles de retroceso desde el último swing) ====
    fib = _calcular_niveles_fibonacci(df)
    for nivel, valor in fib.items():
        df[f'fib_{nivel}'] = (c - valor) / (valor + 1e-8)  # distancia al nivel

    # ==== 12. OBV (On Balance Volume) ====
    df['obv'] = _obv(c, vol)
    df['obv_norm'] = (df['obv'] - df['obv'].rolling(50).mean()) / (df['obv'].rolling(50).std() + 1e-8)

    # ==== 13. VWAP (Volume Weighted Average Price) ====
    df['vwap'] = (tp * vol).cumsum() / (vol.cumsum() + 1e-8)
    df['dist_vwap'] = (c - df['vwap']) / (df['vwap'] + 1e-8)

    # ==== 14. DIVERGENCIAS (señal de cambio de momentum) ====
    df['divergencia_rsi'] = _detectar_divergencia(c, df['rsi'])

    # ==== 15. PATRONES DE VELAS YA INTEGRADOS (placeholder, lo llena motor_analisis) ====
    # Se mantienen como columna neutra para no romper shapes
    df['pattern_score'] = 0.0

    # Rellenar NaN
    df.fillna(0, inplace=True)
    return df


def _rsi(series, period=14):
    """RSI clásico."""
    delta = series.diff()
    gain = delta.where(delta > 0, 0).rolling(window=period).mean()
    loss = -delta.where(delta < 0, 0).rolling(window=period).mean()
    rs = gain / (loss + 1e-8)
    return 100 - (100 / (1 + rs))


def _adx(high, low, close, period=14):
    """Average Directional Index (fuerza de tendencia)."""
    plus_dm = high.diff()
    minus_dm = -low.diff()
    plus_dm[plus_dm < 0] = 0
    minus_dm[minus_dm < 0] = 0
    tr = np.maximum(high - low, np.maximum(np.abs(high - close.shift(1)), np.abs(low - close.shift(1))))
    atr = pd.Series(tr).rolling(window=period).mean()
    plus_di = 100 * (plus_dm.rolling(period).mean() / (atr + 1e-8))
    minus_di = 100 * (minus_dm.rolling(period).mean() / (atr + 1e-8))
    dx = (np.abs(plus_di - minus_di) / (plus_di + minus_di + 1e-8)) * 100
    adx = dx.rolling(period).mean()
    return adx / 100.0  # normalizado


def _calcular_niveles_fibonacci(df, ventana_swing=50):
    """
    Calcula niveles de retroceso Fibonacci (38.2%, 50%, 61.8%) desde el último swing.
    Manual de Admiral Markets: estos son los retrocesos más confiables.
    """
    if len(df) < ventana_swing:
        return {'38.2': 0, '50.0': 0, '61.8': 0, '100.0': 0}

    recientes = df.tail(ventana_swing)
    max_p = recientes['high'].max()
    min_p = recientes['low'].min()
    diff = max_p - min_p

    return {
        '38.2': max_p - diff * 0.382,
        '50.0': max_p - diff * 0.500,
        '61.8': max_p - diff * 0.618,
        '100.0': max_p - diff * 1.000,
    }


def _obv(close, volume):
    """On Balance Volume."""
    direction = np.sign(close.diff()).fillna(0)
    return (volume * direction).cumsum()


def _detectar_divergencia(close, rsi, ventana=10):
    """
    Detecta divergencia RSI vs precio en los últimos N periodos.
    +1 = divergencia alcista (precio baja, RSI sube)
    -1 = divergencia bajista (precio sube, RSI baja)
    0 = sin divergencia
    """
    if len(close) < ventana * 2:
        return pd.Series(np.zeros(len(close)), index=close.index)

    result = pd.Series(np.zeros(len(close)), index=close.index)
    for i in range(ventana, len(close)):
        ventana_pre = close.iloc[i - ventana:i]
        ventana_act = close.iloc[i - ventana // 2:i]
        rsi_pre = rsi.iloc[i - ventana:i - ventana // 2].mean()
        rsi_act = rsi.iloc[i - ventana // 2:i].mean()
        close_pre = ventana_pre.mean()
        close_act = ventana_act.mean()

        if close_act < close_pre and rsi_act > rsi_pre:
            result.iloc[i] = 1.0
        elif close_act > close_pre and rsi_act < rsi_pre:
            result.iloc[i] = -1.0

    return result


def calcular_soportes_resistencias(df, ventana=50, sensibilidad=0.002):
    """
    Detecta zonas de soporte y resistencia por clustering de precios.
    Usado por las estrategias de breakout y rebote.
    """
    if len(df) < ventana:
        return [], []
    recientes = df.tail(ventana)
    maxs = recientes['high'].values
    mins = recientes['low'].values

    resistencias = []
    for i in range(2, len(maxs) - 2):
        if maxs[i] > maxs[i - 1] and maxs[i] > maxs[i + 1] and \
           maxs[i] > maxs[i - 2] and maxs[i] > maxs[i + 2]:
            resistencias.append(maxs[i])

    soportes = []
    for i in range(2, len(mins) - 2):
        if mins[i] < mins[i - 1] and mins[i] < mins[i + 1] and \
           mins[i] < mins[i - 2] and mins[i] < mins[i + 2]:
            soportes.append(mins[i])

    def clusterizar(levels):
        if not levels:
            return []
        levels = sorted(levels)
        clusters = [[levels[0]]]
        for lv in levels[1:]:
            if abs(lv - clusters[-1][-1]) / (clusters[-1][-1] + 1e-8) < sensibilidad:
                clusters[-1].append(lv)
            else:
                clusters.append([lv])
        return [sum(c) / len(c) for c in clusters]

    return clusterizar(soportes), clusterizar(resistencias)