"""
Cross-library wrapper registry — comprehensive indicator coverage.

Unified interface: execute_indicator(library, indicator, data, df=None, **kwargs)
Supported libraries: ferro_ta, talib, pandas_ta, ta, tulipy, finta
50+ indicators across all categories.
"""
from __future__ import annotations
from typing import Any
import numpy as np

def _try_import(name):
    try:
        import importlib; return importlib.import_module(name)
    except ImportError: return None

_talib = _try_import("talib")
_pta   = _try_import("pandas_ta")
_ta    = _try_import("ta")
_tl    = _try_import("tulipy")
_fi_m  = _try_import("finta")
_fi    = getattr(_fi_m, "TA", None) if _fi_m else None

def available_libraries():
    libs = ["ferro_ta"]
    if _talib: libs.append("talib")
    if _pta:   libs.append("pandas_ta")
    if _ta:    libs.append("ta")
    if _tl:    libs.append("tulipy")
    if _fi:    libs.append("finta")
    return libs

def is_supported(library: str, indicator: str) -> bool:
    """Return True if a wrapper exists for the given (library, indicator) pair."""
    if library not in available_libraries():
        return False
    return (library, indicator) in REGISTRY

def _strip_nan(arr):
    a = np.asarray(arr, dtype=np.float64).ravel()
    return a[np.isfinite(a)]

def _c64(a):
    return np.ascontiguousarray(a, dtype=np.float64)

def _empty():
    return np.array([], dtype=np.float64)

def _first_col(df, prefix):
    col = next((c for c in df.columns if c.startswith(prefix)), None)
    return _strip_nan(df[col].values) if col is not None else _empty()

# ============================================================
# OVERLAP
# ============================================================
def _sma_ft(d,df,timeperiod=20,**_):
    import ferro_ta; return _strip_nan(ferro_ta.SMA(d["close"],timeperiod=timeperiod))
def _sma_tl(d,df,timeperiod=20,**_): return _strip_nan(_talib.SMA(d["close"],timeperiod=timeperiod))
def _sma_pt(d,df,timeperiod=20,**_): return _strip_nan(_pta.sma(df["close"],length=timeperiod).values)
def _sma_ta(d,df,timeperiod=20,**_):
    from ta.trend import SMAIndicator; return _strip_nan(SMAIndicator(df["close"],window=timeperiod).sma_indicator().values)
def _sma_tu(d,df,timeperiod=20,**_): return _strip_nan(_tl.sma(_c64(d["close"]),period=timeperiod))
def _sma_fi(d,df,timeperiod=20,**_): return _strip_nan(_fi.SMA(df,timeperiod).values)

def _ema_ft(d,df,timeperiod=20,**_):
    import ferro_ta; return _strip_nan(ferro_ta.EMA(d["close"],timeperiod=timeperiod))
def _ema_tl(d,df,timeperiod=20,**_): return _strip_nan(_talib.EMA(d["close"],timeperiod=timeperiod))
def _ema_pt(d,df,timeperiod=20,**_): return _strip_nan(_pta.ema(df["close"],length=timeperiod).values)
def _ema_ta(d,df,timeperiod=20,**_):
    from ta.trend import EMAIndicator; return _strip_nan(EMAIndicator(df["close"],window=timeperiod).ema_indicator().values)
def _ema_tu(d,df,timeperiod=20,**_): return _strip_nan(_tl.ema(_c64(d["close"]),period=timeperiod))
def _ema_fi(d,df,timeperiod=20,**_): return _strip_nan(_fi.EMA(df,timeperiod).values)

def _wma_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.WMA(d["close"],timeperiod=timeperiod))
def _wma_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.WMA(d["close"],timeperiod=timeperiod))
def _wma_pt(d,df,timeperiod=14,**_): return _strip_nan(_pta.wma(df["close"],length=timeperiod).values)
def _wma_ta(d,df,**_): return _empty()
_wma_ta._stub = True
def _wma_tu(d,df,timeperiod=14,**_): return _strip_nan(_tl.wma(_c64(d["close"]),period=timeperiod))
def _wma_fi(d,df,timeperiod=14,**_): return _strip_nan(_fi.WMA(df,timeperiod).values)

def _dema_ft(d,df,timeperiod=20,**_):
    import ferro_ta; return _strip_nan(ferro_ta.DEMA(d["close"],timeperiod=timeperiod))
def _dema_tl(d,df,timeperiod=20,**_): return _strip_nan(_talib.DEMA(d["close"],timeperiod=timeperiod))
def _dema_pt(d,df,timeperiod=20,**_): return _strip_nan(_pta.dema(df["close"],length=timeperiod).values)
def _dema_ta(d,df,**_): return _empty()
_dema_ta._stub = True
def _dema_tu(d,df,timeperiod=20,**_): return _strip_nan(_tl.dema(_c64(d["close"]),period=timeperiod))
def _dema_fi(d,df,timeperiod=20,**_): return _strip_nan(_fi.DEMA(df,timeperiod).values)

def _tema_ft(d,df,timeperiod=20,**_):
    import ferro_ta; return _strip_nan(ferro_ta.TEMA(d["close"],timeperiod=timeperiod))
def _tema_tl(d,df,timeperiod=20,**_): return _strip_nan(_talib.TEMA(d["close"],timeperiod=timeperiod))
def _tema_pt(d,df,timeperiod=20,**_): return _strip_nan(_pta.tema(df["close"],length=timeperiod).values)
def _tema_ta(d,df,**_): return _empty()
_tema_ta._stub = True
def _tema_tu(d,df,timeperiod=20,**_): return _strip_nan(_tl.tema(_c64(d["close"]),period=timeperiod))
def _tema_fi(d,df,timeperiod=20,**_): return _strip_nan(_fi.TEMA(df,timeperiod).values)

def _t3_ft(d,df,timeperiod=5,**_):
    import ferro_ta; return _strip_nan(ferro_ta.T3(d["close"],timeperiod=timeperiod))
def _t3_tl(d,df,timeperiod=5,**_): return _strip_nan(_talib.T3(d["close"],timeperiod=timeperiod))
def _t3_pt(d,df,timeperiod=5,**_): return _strip_nan(_pta.t3(df["close"],length=timeperiod).values)
def _t3_ta(d,df,**_): return _empty()
_t3_ta._stub = True
def _t3_tu(d,df,**_): return _empty()
_t3_tu._stub = True
def _t3_fi(d,df,**_): return _empty()
_t3_fi._stub = True

def _trima_ft(d,df,timeperiod=20,**_):
    import ferro_ta; return _strip_nan(ferro_ta.TRIMA(d["close"],timeperiod=timeperiod))
def _trima_tl(d,df,timeperiod=20,**_): return _strip_nan(_talib.TRIMA(d["close"],timeperiod=timeperiod))
def _trima_pt(d,df,timeperiod=20,**_): return _strip_nan(_pta.trima(df["close"],length=timeperiod).values)
def _trima_ta(d,df,**_): return _empty()
_trima_ta._stub = True
def _trima_tu(d,df,timeperiod=20,**_): return _strip_nan(_tl.trima(_c64(d["close"]),period=timeperiod))
def _trima_fi(d,df,timeperiod=20,**_): return _strip_nan(_fi.TRIMA(df,timeperiod).values)

def _kama_ft(d,df,timeperiod=10,**_):
    import ferro_ta; return _strip_nan(ferro_ta.KAMA(d["close"],timeperiod=timeperiod))
def _kama_tl(d,df,timeperiod=10,**_): return _strip_nan(_talib.KAMA(d["close"],timeperiod=timeperiod))
def _kama_pt(d,df,timeperiod=10,**_): return _strip_nan(_pta.kama(df["close"],length=timeperiod).values)
def _kama_ta(d,df,**_): return _empty()
_kama_ta._stub = True
def _kama_tu(d,df,timeperiod=10,**_): return _strip_nan(_tl.kama(_c64(d["close"]),period=timeperiod))
def _kama_fi(d,df,**_): return _empty()
_kama_fi._stub = True

def _hma_ft(d,df,timeperiod=16,**_):
    import ferro_ta; return _strip_nan(ferro_ta.HULL_MA(d["close"],timeperiod=timeperiod))
def _hma_tl(d,df,**_): return _empty()
_hma_tl._stub = True
def _hma_pt(d,df,timeperiod=16,**_): return _strip_nan(_pta.hma(df["close"],length=timeperiod).values)
def _hma_ta(d,df,**_): return _empty()
_hma_ta._stub = True
def _hma_tu(d,df,timeperiod=16,**_): return _strip_nan(_tl.hma(_c64(d["close"]),period=timeperiod))
def _hma_fi(d,df,timeperiod=16,**_): return _strip_nan(_fi.HMA(df,timeperiod).values)

def _vwma_ft(d,df,timeperiod=20,**_):
    import ferro_ta; return _strip_nan(ferro_ta.VWMA(d["close"],d["volume"],timeperiod=timeperiod))
def _vwma_tl(d,df,**_): return _empty()
_vwma_tl._stub = True
def _vwma_pt(d,df,timeperiod=20,**_):
    r=_pta.vwma(df["close"],df["volume"],length=timeperiod); return _strip_nan(r.values) if r is not None else _empty()
def _vwma_ta(d,df,**_): return _empty()
_vwma_ta._stub = True
def _vwma_tu(d,df,timeperiod=20,**_): return _strip_nan(_tl.vwma(_c64(d["close"]),_c64(d["volume"]),period=timeperiod))
def _vwma_fi(d,df,**_): return _empty()
_vwma_fi._stub = True

def _midpoint_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.MIDPOINT(d["close"],timeperiod=timeperiod))
def _midpoint_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.MIDPOINT(d["close"],timeperiod=timeperiod))
def _midpoint_pt(d,df,**_): return _empty()
_midpoint_pt._stub = True
def _midpoint_ta(d,df,**_): return _empty()
_midpoint_ta._stub = True
def _midpoint_tu(d,df,**_): return _empty()
_midpoint_tu._stub = True
def _midpoint_fi(d,df,**_): return _empty()
_midpoint_fi._stub = True

def _midprice_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.MIDPRICE(d["high"],d["low"],timeperiod=timeperiod))
def _midprice_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.MIDPRICE(d["high"],d["low"],timeperiod=timeperiod))
def _midprice_pt(d,df,**_): return _empty()
_midprice_pt._stub = True
def _midprice_ta(d,df,**_): return _empty()
_midprice_ta._stub = True
def _midprice_tu(d,df,**_): return _empty()
_midprice_tu._stub = True
def _midprice_fi(d,df,**_): return _empty()
_midprice_fi._stub = True

# ============================================================
# MOMENTUM
# ============================================================
def _rsi_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.RSI(d["close"],timeperiod=timeperiod))
def _rsi_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.RSI(d["close"],timeperiod=timeperiod))
def _rsi_pt(d,df,timeperiod=14,**_): return _strip_nan(_pta.rsi(df["close"],length=timeperiod).values)
def _rsi_ta(d,df,timeperiod=14,**_):
    from ta.momentum import RSIIndicator; return _strip_nan(RSIIndicator(df["close"],window=timeperiod).rsi().values)
def _rsi_tu(d,df,timeperiod=14,**_): return _strip_nan(_tl.rsi(_c64(d["close"]),period=timeperiod))
def _rsi_fi(d,df,timeperiod=14,**_): return _strip_nan(_fi.RSI(df,timeperiod).values)

def _macd_ft(d,df,fastperiod=12,slowperiod=26,signalperiod=9,**_):
    import ferro_ta; m,s,h=ferro_ta.MACD(d["close"],fastperiod=fastperiod,slowperiod=slowperiod,signalperiod=signalperiod); return _strip_nan(m)
def _macd_tl(d,df,fastperiod=12,slowperiod=26,signalperiod=9,**_):
    m,s,h=_talib.MACD(d["close"],fastperiod=fastperiod,slowperiod=slowperiod,signalperiod=signalperiod); return _strip_nan(m)
def _macd_pt(d,df,fastperiod=12,slowperiod=26,signalperiod=9,**_):
    r=_pta.macd(df["close"],fast=fastperiod,slow=slowperiod,signal=signalperiod); return _first_col(r,"MACD_")
def _macd_ta(d,df,fastperiod=12,slowperiod=26,signalperiod=9,**_):
    from ta.trend import MACD; return _strip_nan(MACD(df["close"],window_fast=fastperiod,window_slow=slowperiod,window_sign=signalperiod).macd().values)
def _macd_tu(d,df,fastperiod=12,slowperiod=26,signalperiod=9,**_):
    m,s,h=_tl.macd(_c64(d["close"]),short_period=fastperiod,long_period=slowperiod,signal_period=signalperiod); return _strip_nan(m)
def _macd_fi(d,df,fastperiod=12,slowperiod=26,signalperiod=9,**_):
    return _strip_nan(_fi.MACD(df,fastperiod,slowperiod,signalperiod)["MACD"].values)

def _stoch_ft(d,df,fastk_period=14,slowk_period=3,slowd_period=3,**_):
    import ferro_ta; k,dd=ferro_ta.STOCH(d["high"],d["low"],d["close"],fastk_period=fastk_period,slowk_period=slowk_period,slowd_period=slowd_period); return _strip_nan(k)
def _stoch_tl(d,df,fastk_period=14,slowk_period=3,slowd_period=3,**_):
    k,dd=_talib.STOCH(d["high"],d["low"],d["close"],fastk_period=fastk_period,slowk_period=slowk_period,slowd_period=slowd_period); return _strip_nan(k)
def _stoch_pt(d,df,fastk_period=14,slowk_period=3,slowd_period=3,**_):
    r=_pta.stoch(df["high"],df["low"],df["close"],k=fastk_period,d=slowd_period)
    return _first_col(r,"STOCHk_") if r is not None else _empty()
def _stoch_ta(d,df,fastk_period=14,**_):
    from ta.momentum import StochasticOscillator; return _strip_nan(StochasticOscillator(df["high"],df["low"],df["close"],window=fastk_period).stoch().values)
def _stoch_tu(d,df,fastk_period=14,slowk_period=3,slowd_period=3,**_):
    k,dd=_tl.stoch(_c64(d["high"]),_c64(d["low"]),_c64(d["close"]),pct_k_period=fastk_period,pct_k_slowing_period=slowk_period,pct_d_period=slowd_period); return _strip_nan(k)
def _stoch_fi(d,df,fastk_period=14,**_): return _strip_nan(_fi.STOCH(df,fastk_period).values)

def _cci_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.CCI(d["high"],d["low"],d["close"],timeperiod=timeperiod))
def _cci_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.CCI(d["high"],d["low"],d["close"],timeperiod=timeperiod))
def _cci_pt(d,df,timeperiod=14,**_): return _strip_nan(_pta.cci(df["high"],df["low"],df["close"],length=timeperiod).values)
def _cci_ta(d,df,timeperiod=14,**_):
    from ta.trend import CCIIndicator; return _strip_nan(CCIIndicator(df["high"],df["low"],df["close"],window=timeperiod).cci().values)
def _cci_tu(d,df,timeperiod=14,**_): return _strip_nan(_tl.cci(_c64(d["high"]),_c64(d["low"]),_c64(d["close"]),period=timeperiod))
def _cci_fi(d,df,timeperiod=14,**_): return _strip_nan(_fi.CCI(df,timeperiod).values)

def _willr_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.WILLR(d["high"],d["low"],d["close"],timeperiod=timeperiod))
def _willr_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.WILLR(d["high"],d["low"],d["close"],timeperiod=timeperiod))
def _willr_pt(d,df,timeperiod=14,**_): return _strip_nan(_pta.willr(df["high"],df["low"],df["close"],length=timeperiod).values)
def _willr_ta(d,df,timeperiod=14,**_):
    from ta.momentum import WilliamsRIndicator; return _strip_nan(WilliamsRIndicator(df["high"],df["low"],df["close"],lbp=timeperiod).williams_r().values)
def _willr_tu(d,df,timeperiod=14,**_): return _strip_nan(_tl.willr(_c64(d["high"]),_c64(d["low"]),_c64(d["close"]),period=timeperiod))
def _willr_fi(d,df,timeperiod=14,**_): return _strip_nan(_fi.WILLIAMS(df,timeperiod).values)

def _aroon_ft(d,df,timeperiod=14,**_):
    import ferro_ta; dn,up=ferro_ta.AROON(d["high"],d["low"],timeperiod=timeperiod); return _strip_nan(up)
def _aroon_tl(d,df,timeperiod=14,**_):
    dn,up=_talib.AROON(d["high"],d["low"],timeperiod=timeperiod); return _strip_nan(up)
def _aroon_pt(d,df,timeperiod=14,**_):
    r=_pta.aroon(df["high"],df["low"],length=timeperiod); return _first_col(r,"AROONU_") if r is not None else _empty()
def _aroon_ta(d,df,timeperiod=14,**_):
    from ta.trend import AroonIndicator; return _strip_nan(AroonIndicator(df["high"],df["low"],window=timeperiod).aroon_up().values)
def _aroon_tu(d,df,timeperiod=14,**_):
    dn,up=_tl.aroon(_c64(d["high"]),_c64(d["low"]),period=timeperiod); return _strip_nan(up)
def _aroon_fi(d,df,**_): return _empty()
_aroon_fi._stub = True

def _aroonosc_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.AROONOSC(d["high"],d["low"],timeperiod=timeperiod))
def _aroonosc_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.AROONOSC(d["high"],d["low"],timeperiod=timeperiod))
def _aroonosc_pt(d,df,**_): return _empty()
_aroonosc_pt._stub = True
def _aroonosc_ta(d,df,**_): return _empty()
_aroonosc_ta._stub = True
def _aroonosc_tu(d,df,timeperiod=14,**_): return _strip_nan(_tl.aroonosc(_c64(d["high"]),_c64(d["low"]),period=timeperiod))
def _aroonosc_fi(d,df,**_): return _empty()
_aroonosc_fi._stub = True

def _adx_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.ADX(d["high"],d["low"],d["close"],timeperiod=timeperiod))
def _adx_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.ADX(d["high"],d["low"],d["close"],timeperiod=timeperiod))
def _adx_pt(d,df,timeperiod=14,**_):
    r=_pta.adx(df["high"],df["low"],df["close"],length=timeperiod); return _first_col(r,"ADX_")
def _adx_ta(d,df,timeperiod=14,**_):
    from ta.trend import ADXIndicator; return _strip_nan(ADXIndicator(df["high"],df["low"],df["close"],window=timeperiod).adx().values)
def _adx_tu(d,df,timeperiod=14,**_): return _strip_nan(_tl.adx(_c64(d["high"]),_c64(d["low"]),_c64(d["close"]),period=timeperiod))
def _adx_fi(d,df,**_): return _empty()
_adx_fi._stub = True

def _mom_ft(d,df,timeperiod=10,**_):
    import ferro_ta; return _strip_nan(ferro_ta.MOM(d["close"],timeperiod=timeperiod))
def _mom_tl(d,df,timeperiod=10,**_): return _strip_nan(_talib.MOM(d["close"],timeperiod=timeperiod))
def _mom_pt(d,df,timeperiod=10,**_): return _strip_nan(_pta.mom(df["close"],length=timeperiod).values)
def _mom_ta(d,df,**_): return _empty()
_mom_ta._stub = True
def _mom_tu(d,df,timeperiod=10,**_): return _strip_nan(_tl.mom(_c64(d["close"]),period=timeperiod))
def _mom_fi(d,df,timeperiod=10,**_): return _strip_nan(_fi.MOM(df,timeperiod).values)

def _roc_ft(d,df,timeperiod=10,**_):
    import ferro_ta; return _strip_nan(ferro_ta.ROC(d["close"],timeperiod=timeperiod))
def _roc_tl(d,df,timeperiod=10,**_): return _strip_nan(_talib.ROC(d["close"],timeperiod=timeperiod))
def _roc_pt(d,df,timeperiod=10,**_): return _strip_nan(_pta.roc(df["close"],length=timeperiod).values)
def _roc_ta(d,df,timeperiod=10,**_):
    from ta.momentum import ROCIndicator; return _strip_nan(ROCIndicator(df["close"],window=timeperiod).roc().values)
def _roc_tu(d,df,timeperiod=10,**_): return _strip_nan(_tl.roc(_c64(d["close"]),period=timeperiod) * 100.0)
def _roc_fi(d,df,timeperiod=10,**_): return _strip_nan(_fi.ROC(df,timeperiod).values)

def _cmo_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.CMO(d["close"],timeperiod=timeperiod))
def _cmo_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.CMO(d["close"],timeperiod=timeperiod))
def _cmo_pt(d,df,timeperiod=14,**_): return _strip_nan(_pta.cmo(df["close"],length=timeperiod).values)
def _cmo_ta(d,df,**_): return _empty()
_cmo_ta._stub = True
def _cmo_tu(d,df,timeperiod=14,**_): return _strip_nan(_tl.cmo(_c64(d["close"]),period=timeperiod))
def _cmo_fi(d,df,timeperiod=14,**_): return _strip_nan(_fi.CMO(df,timeperiod).values)

def _ppo_ft(d,df,fastperiod=12,slowperiod=26,**_):
    import ferro_ta; ppo,sig,hist=ferro_ta.PPO(d["close"],fastperiod=fastperiod,slowperiod=slowperiod); return _strip_nan(ppo)
def _ppo_tl(d,df,fastperiod=12,slowperiod=26,**_): return _strip_nan(_talib.PPO(d["close"],fastperiod=fastperiod,slowperiod=slowperiod))
def _ppo_pt(d,df,fastperiod=12,slowperiod=26,**_):
    r=_pta.ppo(df["close"],fast=fastperiod,slow=slowperiod)
    return _strip_nan(r.iloc[:,0].values) if r is not None else _empty()
def _ppo_ta(d,df,**_): return _empty()
_ppo_ta._stub = True
def _ppo_tu(d,df,fastperiod=12,slowperiod=26,**_): return _strip_nan(_tl.ppo(_c64(d["close"]),short_period=fastperiod,long_period=slowperiod))
def _ppo_fi(d,df,fastperiod=12,slowperiod=26,**_): return _strip_nan(_fi.PPO(df,fastperiod,slowperiod).values)

def _trix_ft(d,df,timeperiod=18,**_):
    import ferro_ta; return _strip_nan(ferro_ta.TRIX(d["close"],timeperiod=timeperiod))
def _trix_tl(d,df,timeperiod=18,**_): return _strip_nan(_talib.TRIX(d["close"],timeperiod=timeperiod))
def _trix_pt(d,df,timeperiod=18,**_):
    r=_pta.trix(df["close"],length=timeperiod)
    return _strip_nan(r.iloc[:,0].values) if r is not None else _empty()
def _trix_ta(d,df,timeperiod=18,**_):
    from ta.trend import TRIXIndicator; return _strip_nan(TRIXIndicator(df["close"],window=timeperiod).trix().values)
def _trix_tu(d,df,timeperiod=18,**_): return _strip_nan(_tl.trix(_c64(d["close"]),period=timeperiod))
def _trix_fi(d,df,timeperiod=18,**_): return _strip_nan(_fi.TRIX(df,timeperiod).values)

def _tsf_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.TSF(d["close"],timeperiod=timeperiod))
def _tsf_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.TSF(d["close"],timeperiod=timeperiod))
def _tsf_pt(d,df,**_): return _empty()
_tsf_pt._stub = True
def _tsf_ta(d,df,**_): return _empty()
_tsf_ta._stub = True
def _tsf_tu(d,df,timeperiod=14,**_): return _strip_nan(_tl.tsf(_c64(d["close"]),period=timeperiod))
def _tsf_fi(d,df,**_): return _empty()
_tsf_fi._stub = True

def _ultosc_ft(d,df,timeperiod1=7,timeperiod2=14,timeperiod3=28,**_):
    import ferro_ta; return _strip_nan(ferro_ta.ULTOSC(d["high"],d["low"],d["close"],timeperiod1=timeperiod1,timeperiod2=timeperiod2,timeperiod3=timeperiod3))
def _ultosc_tl(d,df,timeperiod1=7,timeperiod2=14,timeperiod3=28,**_):
    return _strip_nan(_talib.ULTOSC(d["high"],d["low"],d["close"],timeperiod1=timeperiod1,timeperiod2=timeperiod2,timeperiod3=timeperiod3))
def _ultosc_pt(d,df,**_): return _empty()
_ultosc_pt._stub = True
def _ultosc_ta(d,df,timeperiod1=7,timeperiod2=14,timeperiod3=28,**_):
    from ta.momentum import UltimateOscillator
    return _strip_nan(UltimateOscillator(df["high"],df["low"],df["close"],window1=timeperiod1,window2=timeperiod2,window3=timeperiod3).ultimate_oscillator().values)
def _ultosc_tu(d,df,timeperiod1=7,timeperiod2=14,timeperiod3=28,**_):
    return _strip_nan(_tl.ultosc(_c64(d["high"]),_c64(d["low"]),_c64(d["close"]),short_period=timeperiod1,medium_period=timeperiod2,long_period=timeperiod3))
def _ultosc_fi(d,df,**_): return _empty()
_ultosc_fi._stub = True

def _bop_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.BOP(d["open"],d["high"],d["low"],d["close"]))
def _bop_tl(d,df,**_): return _strip_nan(_talib.BOP(d["open"],d["high"],d["low"],d["close"]))
def _bop_pt(d,df,**_):
    r=_pta.bop(df["open"],df["high"],df["low"],df["close"]); return _strip_nan(r.values) if r is not None else _empty()
def _bop_ta(d,df,**_): return _empty()
_bop_ta._stub = True
def _bop_tu(d,df,**_): return _strip_nan(_tl.bop(_c64(d["open"]),_c64(d["high"]),_c64(d["low"]),_c64(d["close"])))
def _bop_fi(d,df,**_): return _empty()
_bop_fi._stub = True

def _plusdi_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.PLUS_DI(d["high"],d["low"],d["close"],timeperiod=timeperiod))
def _plusdi_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.PLUS_DI(d["high"],d["low"],d["close"],timeperiod=timeperiod))
def _plusdi_pt(d,df,timeperiod=14,**_):
    r=_pta.adx(df["high"],df["low"],df["close"],length=timeperiod); return _first_col(r,"DMP_") if r is not None else _empty()
def _plusdi_ta(d,df,**_): return _empty()
_plusdi_ta._stub = True
def _plusdi_tu(d,df,timeperiod=14,**_):
    pdi,mdi=_tl.di(_c64(d["high"]),_c64(d["low"]),_c64(d["close"]),period=timeperiod); return _strip_nan(pdi)
def _plusdi_fi(d,df,**_): return _empty()
_plusdi_fi._stub = True

def _minusdi_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.MINUS_DI(d["high"],d["low"],d["close"],timeperiod=timeperiod))
def _minusdi_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.MINUS_DI(d["high"],d["low"],d["close"],timeperiod=timeperiod))
def _minusdi_pt(d,df,**_): return _empty()
_minusdi_pt._stub = True
def _minusdi_ta(d,df,**_): return _empty()
_minusdi_ta._stub = True
def _minusdi_tu(d,df,timeperiod=14,**_):
    pdi,mdi=_tl.di(_c64(d["high"]),_c64(d["low"]),_c64(d["close"]),period=timeperiod); return _strip_nan(mdi)
def _minusdi_fi(d,df,**_): return _empty()
_minusdi_fi._stub = True

# ============================================================
# VOLATILITY
# ============================================================
def _bb_ft(d,df,timeperiod=20,nbdevup=2.0,nbdevdn=2.0,**_):
    import ferro_ta; u,m,l=ferro_ta.BBANDS(d["close"],timeperiod=timeperiod,nbdevup=nbdevup,nbdevdn=nbdevdn); return _strip_nan(u)
def _bb_tl(d,df,timeperiod=20,nbdevup=2.0,nbdevdn=2.0,**_):
    u,m,l=_talib.BBANDS(d["close"],timeperiod=timeperiod,nbdevup=nbdevup,nbdevdn=nbdevdn); return _strip_nan(u)
def _bb_pt(d,df,timeperiod=20,nbdevup=2.0,**_):
    r=_pta.bbands(df["close"],length=timeperiod,std=nbdevup); return _first_col(r,"BBU_")
def _bb_ta(d,df,timeperiod=20,nbdevup=2.0,**_):
    from ta.volatility import BollingerBands; return _strip_nan(BollingerBands(df["close"],window=timeperiod,window_dev=nbdevup).bollinger_hband().values)
def _bb_tu(d,df,timeperiod=20,nbdevup=2.0,**_):
    lo,mi,up=_tl.bbands(_c64(d["close"]),period=timeperiod,stddev=nbdevup); return _strip_nan(up)
def _bb_fi(d,df,timeperiod=20,**_): return _strip_nan(_fi.BBANDS(df,timeperiod)["BB_UPPER"].values)

def _atr_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.ATR(d["high"],d["low"],d["close"],timeperiod=timeperiod))
def _atr_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.ATR(d["high"],d["low"],d["close"],timeperiod=timeperiod))
def _atr_pt(d,df,timeperiod=14,**_): return _strip_nan(_pta.atr(df["high"],df["low"],df["close"],length=timeperiod).values)
def _atr_ta(d,df,timeperiod=14,**_):
    from ta.volatility import AverageTrueRange; return _strip_nan(AverageTrueRange(df["high"],df["low"],df["close"],window=timeperiod).average_true_range().values)
def _atr_tu(d,df,timeperiod=14,**_): return _strip_nan(_tl.atr(_c64(d["high"]),_c64(d["low"]),_c64(d["close"]),period=timeperiod))
def _atr_fi(d,df,timeperiod=14,**_): return _strip_nan(_fi.ATR(df,timeperiod).values)

def _natr_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.NATR(d["high"],d["low"],d["close"],timeperiod=timeperiod))
def _natr_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.NATR(d["high"],d["low"],d["close"],timeperiod=timeperiod))
def _natr_pt(d,df,timeperiod=14,**_): return _strip_nan(_pta.natr(df["high"],df["low"],df["close"],length=timeperiod).values)
def _natr_ta(d,df,**_): return _empty()
_natr_ta._stub = True
def _natr_tu(d,df,timeperiod=14,**_): return _strip_nan(_tl.natr(_c64(d["high"]),_c64(d["low"]),_c64(d["close"]),period=timeperiod))
def _natr_fi(d,df,**_): return _empty()
_natr_fi._stub = True

def _trange_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.TRANGE(d["high"],d["low"],d["close"]))
def _trange_tl(d,df,**_): return _strip_nan(_talib.TRANGE(d["high"],d["low"],d["close"]))
def _trange_pt(d,df,**_):
    r=_pta.true_range(df["high"],df["low"],df["close"]); return _strip_nan(r.values) if r is not None else _empty()
def _trange_ta(d,df,**_): return _empty()
_trange_ta._stub = True
def _trange_tu(d,df,**_): return _strip_nan(_tl.tr(_c64(d["high"]),_c64(d["low"]),_c64(d["close"])))
def _trange_fi(d,df,**_): return _strip_nan(_fi.TR(df).values)

def _stddev_ft(d,df,timeperiod=20,**_):
    import ferro_ta; return _strip_nan(ferro_ta.STDDEV(d["close"],timeperiod=timeperiod))
def _stddev_tl(d,df,timeperiod=20,**_): return _strip_nan(_talib.STDDEV(d["close"],timeperiod=timeperiod))
def _stddev_pt(d,df,timeperiod=20,**_):
    r=_pta.stdev(df["close"],length=timeperiod); return _strip_nan(r.values) if r is not None else _empty()
def _stddev_ta(d,df,**_): return _empty()
_stddev_ta._stub = True
def _stddev_tu(d,df,timeperiod=20,**_): return _strip_nan(_tl.stddev(_c64(d["close"]),period=timeperiod))
def _stddev_fi(d,df,timeperiod=20,**_): return _strip_nan(_fi.MSD(df,timeperiod).values)

def _var_ft(d,df,timeperiod=20,**_):
    import ferro_ta; return _strip_nan(ferro_ta.VAR(d["close"],timeperiod=timeperiod))
def _var_tl(d,df,timeperiod=20,**_): return _strip_nan(_talib.VAR(d["close"],timeperiod=timeperiod))
def _var_pt(d,df,timeperiod=20,**_):
    r=_pta.variance(df["close"],length=timeperiod); return _strip_nan(r.values) if r is not None else _empty()
def _var_ta(d,df,**_): return _empty()
_var_ta._stub = True
def _var_tu(d,df,timeperiod=20,**_): return _strip_nan(_tl.var(_c64(d["close"]),period=timeperiod))
def _var_fi(d,df,**_): return _empty()
_var_fi._stub = True

def _sar_ft(d,df,acceleration=0.02,maximum=0.2,**_):
    import ferro_ta; return _strip_nan(ferro_ta.SAR(d["high"],d["low"],acceleration=acceleration,maximum=maximum))
def _sar_tl(d,df,acceleration=0.02,maximum=0.2,**_): return _strip_nan(_talib.SAR(d["high"],d["low"],acceleration=acceleration,maximum=maximum))
def _sar_pt(d,df,**_): return _empty()
_sar_pt._stub = True
def _sar_ta(d,df,**_): return _empty()
_sar_ta._stub = True
def _sar_tu(d,df,acceleration=0.02,maximum=0.2,**_): return _strip_nan(_tl.psar(_c64(d["high"]),_c64(d["low"]),acceleration_factor_step=acceleration,acceleration_factor_maximum=maximum))
def _sar_fi(d,df,**_): return _empty()
_sar_fi._stub = True

def _kc_ft(d,df,timeperiod=20,**_):
    import ferro_ta; u,m,l=ferro_ta.KELTNER_CHANNELS(d["high"],d["low"],d["close"],timeperiod=timeperiod); return _strip_nan(u)
def _kc_tl(d,df,**_): return _empty()
_kc_tl._stub = True
def _kc_pt(d,df,timeperiod=20,**_):
    r=_pta.kc(df["high"],df["low"],df["close"],length=timeperiod)
    if r is None: return _empty()
    col=next((c for c in r.columns if "UCe" in c or "UB" in c or c.endswith("U")),None)
    return _strip_nan(r[col].values) if col else _first_col(r,"KC")
def _kc_ta(d,df,timeperiod=20,**_):
    from ta.volatility import KeltnerChannel; return _strip_nan(KeltnerChannel(df["high"],df["low"],df["close"],window=timeperiod).keltner_channel_hband().values)
def _kc_tu(d,df,**_): return _empty()
_kc_tu._stub = True
def _kc_fi(d,df,**_): return _empty()
_kc_fi._stub = True

def _donchian_ft(d,df,timeperiod=20,**_):
    import ferro_ta; u,m,l=ferro_ta.DONCHIAN(d["high"],d["low"],timeperiod=timeperiod); return _strip_nan(u)
def _donchian_tl(d,df,**_): return _empty()
_donchian_tl._stub = True
def _donchian_pt(d,df,timeperiod=20,**_):
    r=_pta.donchian(df["high"],df["low"],lower_length=timeperiod,upper_length=timeperiod)
    return _first_col(r,"DCU_") if r is not None else _empty()
def _donchian_ta(d,df,timeperiod=20,**_):
    from ta.volatility import DonchianChannel; return _strip_nan(DonchianChannel(df["high"],df["low"],df["close"],window=timeperiod).donchian_channel_hband().values)
def _donchian_tu(d,df,**_): return _empty()
_donchian_tu._stub = True
def _donchian_fi(d,df,**_): return _empty()
_donchian_fi._stub = True

def _supertrend_ft(d,df,timeperiod=7,**_):
    import ferro_ta; st,dir_=ferro_ta.SUPERTREND(d["high"],d["low"],d["close"],timeperiod=timeperiod); return _strip_nan(st)
def _supertrend_tl(d,df,**_): return _empty()
_supertrend_tl._stub = True
def _supertrend_pt(d,df,timeperiod=7,**_):
    r=_pta.supertrend(df["high"],df["low"],df["close"],length=timeperiod)
    return _first_col(r,"SUPERT_") if r is not None else _empty()
def _supertrend_ta(d,df,**_): return _empty()
_supertrend_ta._stub = True
def _supertrend_tu(d,df,**_): return _empty()
_supertrend_tu._stub = True
def _supertrend_fi(d,df,**_): return _empty()
_supertrend_fi._stub = True

def _chop_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.CHOPPINESS_INDEX(d["high"],d["low"],d["close"],timeperiod=timeperiod))
def _chop_tl(d,df,**_): return _empty()
_chop_tl._stub = True
def _chop_pt(d,df,timeperiod=14,**_):
    r=_pta.chop(df["high"],df["low"],df["close"],length=timeperiod); return _strip_nan(r.values) if r is not None else _empty()
def _chop_ta(d,df,**_): return _empty()
_chop_ta._stub = True
def _chop_tu(d,df,**_): return _empty()
_chop_tu._stub = True
def _chop_fi(d,df,**_): return _empty()
_chop_fi._stub = True

# ============================================================
# VOLUME
# ============================================================
def _obv_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.OBV(d["close"],d["volume"]))
def _obv_tl(d,df,**_): return _strip_nan(_talib.OBV(d["close"],d["volume"]))
def _obv_pt(d,df,**_): return _strip_nan(_pta.obv(df["close"],df["volume"]).values)
def _obv_ta(d,df,**_):
    from ta.volume import OnBalanceVolumeIndicator; return _strip_nan(OnBalanceVolumeIndicator(df["close"],df["volume"]).on_balance_volume().values)
def _obv_tu(d,df,**_): return _strip_nan(_tl.obv(_c64(d["close"]),_c64(d["volume"])))
def _obv_fi(d,df,**_): return _strip_nan(_fi.OBV(df).values)

def _ad_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.AD(d["high"],d["low"],d["close"],d["volume"]))
def _ad_tl(d,df,**_): return _strip_nan(_talib.AD(d["high"],d["low"],d["close"],d["volume"]))
def _ad_pt(d,df,**_): return _strip_nan(_pta.ad(df["high"],df["low"],df["close"],df["volume"]).values)
def _ad_ta(d,df,**_):
    from ta.volume import AccDistIndexIndicator; return _strip_nan(AccDistIndexIndicator(df["high"],df["low"],df["close"],df["volume"]).acc_dist_index().values)
def _ad_tu(d,df,**_): return _strip_nan(_tl.ad(_c64(d["high"]),_c64(d["low"]),_c64(d["close"]),_c64(d["volume"])))
def _ad_fi(d,df,**_): return _empty()
_ad_fi._stub = True

def _adosc_ft(d,df,fastperiod=3,slowperiod=10,**_):
    import ferro_ta; return _strip_nan(ferro_ta.ADOSC(d["high"],d["low"],d["close"],d["volume"],fastperiod=fastperiod,slowperiod=slowperiod))
def _adosc_tl(d,df,fastperiod=3,slowperiod=10,**_): return _strip_nan(_talib.ADOSC(d["high"],d["low"],d["close"],d["volume"],fastperiod=fastperiod,slowperiod=slowperiod))
def _adosc_pt(d,df,fastperiod=3,slowperiod=10,**_): return _strip_nan(_pta.adosc(df["high"],df["low"],df["close"],df["volume"],fast=fastperiod,slow=slowperiod).values)
def _adosc_ta(d,df,**_): return _empty()
_adosc_ta._stub = True
def _adosc_tu(d,df,fastperiod=3,slowperiod=10,**_): return _strip_nan(_tl.adosc(_c64(d["high"]),_c64(d["low"]),_c64(d["close"]),_c64(d["volume"]),short_period=fastperiod,long_period=slowperiod))
def _adosc_fi(d,df,**_): return _empty()
_adosc_fi._stub = True

def _mfi_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.MFI(d["high"],d["low"],d["close"],d["volume"],timeperiod=timeperiod))
def _mfi_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.MFI(d["high"],d["low"],d["close"],d["volume"],timeperiod=timeperiod))
def _mfi_pt(d,df,timeperiod=14,**_): return _strip_nan(_pta.mfi(df["high"],df["low"],df["close"],df["volume"],length=timeperiod).values)
def _mfi_ta(d,df,timeperiod=14,**_):
    from ta.volume import MFIIndicator; return _strip_nan(MFIIndicator(df["high"],df["low"],df["close"],df["volume"],window=timeperiod).money_flow_index().values)
def _mfi_tu(d,df,timeperiod=14,**_): return _strip_nan(_tl.mfi(_c64(d["high"]),_c64(d["low"]),_c64(d["close"]),_c64(d["volume"]),period=timeperiod))
def _mfi_fi(d,df,timeperiod=14,**_): return _strip_nan(_fi.MFI(df,timeperiod).values)

def _vwap_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.VWAP(d["high"],d["low"],d["close"],d["volume"]))
def _vwap_tl(d,df,**_): return _empty()
_vwap_tl._stub = True
def _vwap_pt(d,df,**_):
    r=_pta.vwap(df["high"],df["low"],df["close"],df["volume"]); return _strip_nan(r.values) if r is not None else _empty()
def _vwap_ta(d,df,**_): return _empty()
_vwap_ta._stub = True
def _vwap_tu(d,df,**_): return _empty()
_vwap_tu._stub = True
def _vwap_fi(d,df,**_):
    return _strip_nan(_fi.VWAP(df).values)

# ============================================================
# PRICE TRANSFORM
# ============================================================
def _avgprice_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.AVGPRICE(d["open"],d["high"],d["low"],d["close"]))
def _avgprice_tl(d,df,**_): return _strip_nan(_talib.AVGPRICE(d["open"],d["high"],d["low"],d["close"]))
def _avgprice_pt(d,df,**_): return _empty()
_avgprice_pt._stub = True
def _avgprice_ta(d,df,**_): return _empty()
_avgprice_ta._stub = True
def _avgprice_tu(d,df,**_): return _strip_nan(_tl.avgprice(_c64(d["open"]),_c64(d["high"]),_c64(d["low"]),_c64(d["close"])))
def _avgprice_fi(d,df,**_): return _empty()
_avgprice_fi._stub = True

def _medprice_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.MEDPRICE(d["high"],d["low"]))
def _medprice_tl(d,df,**_): return _strip_nan(_talib.MEDPRICE(d["high"],d["low"]))
def _medprice_pt(d,df,**_): return _empty()
_medprice_pt._stub = True
def _medprice_ta(d,df,**_): return _empty()
_medprice_ta._stub = True
def _medprice_tu(d,df,**_): return _strip_nan(_tl.medprice(_c64(d["high"]),_c64(d["low"])))
def _medprice_fi(d,df,**_): return _empty()
_medprice_fi._stub = True

def _typprice_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.TYPPRICE(d["high"],d["low"],d["close"]))
def _typprice_tl(d,df,**_): return _strip_nan(_talib.TYPPRICE(d["high"],d["low"],d["close"]))
def _typprice_pt(d,df,**_): return _empty()
_typprice_pt._stub = True
def _typprice_ta(d,df,**_): return _empty()
_typprice_ta._stub = True
def _typprice_tu(d,df,**_): return _strip_nan(_tl.typprice(_c64(d["high"]),_c64(d["low"]),_c64(d["close"])))
def _typprice_fi(d,df,**_): return _empty()
_typprice_fi._stub = True

def _wclprice_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.WCLPRICE(d["high"],d["low"],d["close"]))
def _wclprice_tl(d,df,**_): return _strip_nan(_talib.WCLPRICE(d["high"],d["low"],d["close"]))
def _wclprice_pt(d,df,**_): return _empty()
_wclprice_pt._stub = True
def _wclprice_ta(d,df,**_): return _empty()
_wclprice_ta._stub = True
def _wclprice_tu(d,df,**_): return _strip_nan(_tl.wcprice(_c64(d["high"]),_c64(d["low"]),_c64(d["close"])))
def _wclprice_fi(d,df,**_): return _empty()
_wclprice_fi._stub = True

# ============================================================
# MATH
# ============================================================
def _sqrt_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.SQRT(d["close"]))
def _sqrt_tl(d,df,**_): return _strip_nan(_talib.SQRT(d["close"]))
def _sqrt_pt(d,df,**_): return _empty()
_sqrt_pt._stub = True
def _sqrt_ta(d,df,**_): return _empty()
_sqrt_ta._stub = True
def _sqrt_tu(d,df,**_): return _strip_nan(_tl.sqrt(_c64(d["close"])))
def _sqrt_fi(d,df,**_): return _empty()
_sqrt_fi._stub = True

def _log10_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.LOG10(d["close"]))
def _log10_tl(d,df,**_): return _strip_nan(_talib.LOG10(d["close"]))
def _log10_pt(d,df,**_): return _empty()
_log10_pt._stub = True
def _log10_ta(d,df,**_): return _empty()
_log10_ta._stub = True
def _log10_tu(d,df,**_): return _strip_nan(_tl.log10(_c64(d["close"])))
def _log10_fi(d,df,**_): return _empty()
_log10_fi._stub = True

def _add_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.ADD(d["high"],d["low"]))
def _add_tl(d,df,**_): return _strip_nan(_talib.ADD(d["high"],d["low"]))
def _add_pt(d,df,**_): return _empty()
_add_pt._stub = True
def _add_ta(d,df,**_): return _empty()
_add_ta._stub = True
def _add_tu(d,df,**_): return _strip_nan(_tl.add(_c64(d["high"]),_c64(d["low"])))
def _add_fi(d,df,**_): return _empty()
_add_fi._stub = True

# ============================================================
# STATISTICS
# ============================================================
def _linearreg_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.LINEARREG(d["close"],timeperiod=timeperiod))
def _linearreg_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.LINEARREG(d["close"],timeperiod=timeperiod))
def _linearreg_pt(d,df,**_): return _empty()
_linearreg_pt._stub = True
def _linearreg_ta(d,df,**_): return _empty()
_linearreg_ta._stub = True
def _linearreg_tu(d,df,timeperiod=14,**_): return _strip_nan(_tl.linreg(_c64(d["close"]),period=timeperiod))
def _linearreg_fi(d,df,**_): return _empty()
_linearreg_fi._stub = True

def _linreg_slope_ft(d,df,timeperiod=14,**_):
    import ferro_ta; return _strip_nan(ferro_ta.LINEARREG_SLOPE(d["close"],timeperiod=timeperiod))
def _linreg_slope_tl(d,df,timeperiod=14,**_): return _strip_nan(_talib.LINEARREG_SLOPE(d["close"],timeperiod=timeperiod))
def _linreg_slope_pt(d,df,**_): return _empty()
_linreg_slope_pt._stub = True
def _linreg_slope_ta(d,df,**_): return _empty()
_linreg_slope_ta._stub = True
def _linreg_slope_tu(d,df,timeperiod=14,**_): return _strip_nan(_tl.linregslope(_c64(d["close"]),period=timeperiod))
def _linreg_slope_fi(d,df,**_): return _empty()
_linreg_slope_fi._stub = True

def _correl_ft(d,df,timeperiod=30,**_):
    import ferro_ta; return _strip_nan(ferro_ta.CORREL(d["high"],d["low"],timeperiod=timeperiod))
def _correl_tl(d,df,timeperiod=30,**_): return _strip_nan(_talib.CORREL(d["high"],d["low"],timeperiod=timeperiod))
def _correl_pt(d,df,**_): return _empty()
_correl_pt._stub = True
def _correl_ta(d,df,**_): return _empty()
_correl_ta._stub = True
def _correl_tu(d,df,**_): return _empty()
_correl_tu._stub = True
def _correl_fi(d,df,**_): return _empty()
_correl_fi._stub = True

def _beta_ft(d,df,timeperiod=5,**_):
    import ferro_ta; return _strip_nan(ferro_ta.BETA(d["high"],d["low"],timeperiod=timeperiod))
def _beta_tl(d,df,timeperiod=5,**_): return _strip_nan(_talib.BETA(d["high"],d["low"],timeperiod=timeperiod))
def _beta_pt(d,df,**_): return _empty()
_beta_pt._stub = True
def _beta_ta(d,df,**_): return _empty()
_beta_ta._stub = True
def _beta_tu(d,df,**_): return _empty()
_beta_tu._stub = True
def _beta_fi(d,df,**_): return _empty()
_beta_fi._stub = True

# ============================================================
# CYCLE
# ============================================================
def _ht_dcperiod_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.HT_DCPERIOD(d["close"]))
def _ht_dcperiod_tl(d,df,**_): return _strip_nan(_talib.HT_DCPERIOD(d["close"]))
def _ht_dcperiod_pt(d,df,**_): return _empty()
_ht_dcperiod_pt._stub = True
def _ht_dcperiod_ta(d,df,**_): return _empty()
_ht_dcperiod_ta._stub = True
def _ht_dcperiod_tu(d,df,**_): return _empty()
_ht_dcperiod_tu._stub = True
def _ht_dcperiod_fi(d,df,**_): return _empty()
_ht_dcperiod_fi._stub = True

def _ht_trendmode_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.HT_TRENDMODE(d["close"]).astype(float))
def _ht_trendmode_tl(d,df,**_): return _strip_nan(_talib.HT_TRENDMODE(d["close"]).astype(float))
def _ht_trendmode_pt(d,df,**_): return _empty()
_ht_trendmode_pt._stub = True
def _ht_trendmode_ta(d,df,**_): return _empty()
_ht_trendmode_ta._stub = True
def _ht_trendmode_tu(d,df,**_): return _empty()
_ht_trendmode_tu._stub = True
def _ht_trendmode_fi(d,df,**_): return _empty()
_ht_trendmode_fi._stub = True

# ============================================================
# CANDLESTICK PATTERNS
# ============================================================
def _cdlengulfing_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.CDLENGULFING(d["open"],d["high"],d["low"],d["close"]).astype(float))
def _cdlengulfing_tl(d,df,**_): return _strip_nan(_talib.CDLENGULFING(d["open"],d["high"],d["low"],d["close"]).astype(float))
def _cdlengulfing_pt(d,df,**_): return _empty()
_cdlengulfing_pt._stub = True
def _cdlengulfing_ta(d,df,**_): return _empty()
_cdlengulfing_ta._stub = True
def _cdlengulfing_tu(d,df,**_): return _empty()
_cdlengulfing_tu._stub = True
def _cdlengulfing_fi(d,df,**_): return _empty()
_cdlengulfing_fi._stub = True

def _cdldoji_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.CDLDOJI(d["open"],d["high"],d["low"],d["close"]).astype(float))
def _cdldoji_tl(d,df,**_): return _strip_nan(_talib.CDLDOJI(d["open"],d["high"],d["low"],d["close"]).astype(float))
def _cdldoji_pt(d,df,**_): return _empty()
_cdldoji_pt._stub = True
def _cdldoji_ta(d,df,**_): return _empty()
_cdldoji_ta._stub = True
def _cdldoji_tu(d,df,**_): return _empty()
_cdldoji_tu._stub = True
def _cdldoji_fi(d,df,**_): return _empty()
_cdldoji_fi._stub = True

def _cdlhammer_ft(d,df,**_):
    import ferro_ta; return _strip_nan(ferro_ta.CDLHAMMER(d["open"],d["high"],d["low"],d["close"]).astype(float))
def _cdlhammer_tl(d,df,**_): return _strip_nan(_talib.CDLHAMMER(d["open"],d["high"],d["low"],d["close"]).astype(float))
def _cdlhammer_pt(d,df,**_): return _empty()
_cdlhammer_pt._stub = True
def _cdlhammer_ta(d,df,**_): return _empty()
_cdlhammer_ta._stub = True
def _cdlhammer_tu(d,df,**_): return _empty()
_cdlhammer_tu._stub = True
def _cdlhammer_fi(d,df,**_): return _empty()
_cdlhammer_fi._stub = True

# ============================================================
# REGISTRY BUILD
# ============================================================
REGISTRY: dict[tuple[str,Any], Any] = {}

def _reg(ind, ft, tl, pt, ta_, tu, fi):
    """
    Register wrappers for a given indicator across all libraries.

    Wrappers marked ._stub = True (no-op return _empty()) are not registered,
    so execute_indicator raises KeyError for unsupported (lib, ind). Speed
    benchmarks then skip those pairs and the table shows N/A.
    """
    for lib, fn in [
        ("ferro_ta",  ft),
        ("talib",    tl),
        ("pandas_ta",pt),
        ("ta",       ta_),
        ("tulipy",   tu),
        ("finta",    fi),
    ]:
        if getattr(fn, "_stub", False):
            continue
        REGISTRY[(lib, ind)] = fn

_reg("SMA",_sma_ft,_sma_tl,_sma_pt,_sma_ta,_sma_tu,_sma_fi)
_reg("EMA",_ema_ft,_ema_tl,_ema_pt,_ema_ta,_ema_tu,_ema_fi)
_reg("WMA",_wma_ft,_wma_tl,_wma_pt,_wma_ta,_wma_tu,_wma_fi)
_reg("DEMA",_dema_ft,_dema_tl,_dema_pt,_dema_ta,_dema_tu,_dema_fi)
_reg("TEMA",_tema_ft,_tema_tl,_tema_pt,_tema_ta,_tema_tu,_tema_fi)
_reg("T3",_t3_ft,_t3_tl,_t3_pt,_t3_ta,_t3_tu,_t3_fi)
_reg("TRIMA",_trima_ft,_trima_tl,_trima_pt,_trima_ta,_trima_tu,_trima_fi)
_reg("KAMA",_kama_ft,_kama_tl,_kama_pt,_kama_ta,_kama_tu,_kama_fi)
_reg("HULL_MA",_hma_ft,_hma_tl,_hma_pt,_hma_ta,_hma_tu,_hma_fi)
_reg("VWMA",_vwma_ft,_vwma_tl,_vwma_pt,_vwma_ta,_vwma_tu,_vwma_fi)
_reg("MIDPOINT",_midpoint_ft,_midpoint_tl,_midpoint_pt,_midpoint_ta,_midpoint_tu,_midpoint_fi)
_reg("MIDPRICE",_midprice_ft,_midprice_tl,_midprice_pt,_midprice_ta,_midprice_tu,_midprice_fi)
_reg("RSI",_rsi_ft,_rsi_tl,_rsi_pt,_rsi_ta,_rsi_tu,_rsi_fi)
_reg("MACD",_macd_ft,_macd_tl,_macd_pt,_macd_ta,_macd_tu,_macd_fi)
_reg("STOCH",_stoch_ft,_stoch_tl,_stoch_pt,_stoch_ta,_stoch_tu,_stoch_fi)
_reg("CCI",_cci_ft,_cci_tl,_cci_pt,_cci_ta,_cci_tu,_cci_fi)
_reg("WILLR",_willr_ft,_willr_tl,_willr_pt,_willr_ta,_willr_tu,_willr_fi)
_reg("AROON",_aroon_ft,_aroon_tl,_aroon_pt,_aroon_ta,_aroon_tu,_aroon_fi)
_reg("AROONOSC",_aroonosc_ft,_aroonosc_tl,_aroonosc_pt,_aroonosc_ta,_aroonosc_tu,_aroonosc_fi)
_reg("ADX",_adx_ft,_adx_tl,_adx_pt,_adx_ta,_adx_tu,_adx_fi)
_reg("MOM",_mom_ft,_mom_tl,_mom_pt,_mom_ta,_mom_tu,_mom_fi)
_reg("ROC",_roc_ft,_roc_tl,_roc_pt,_roc_ta,_roc_tu,_roc_fi)
_reg("CMO",_cmo_ft,_cmo_tl,_cmo_pt,_cmo_ta,_cmo_tu,_cmo_fi)
_reg("PPO",_ppo_ft,_ppo_tl,_ppo_pt,_ppo_ta,_ppo_tu,_ppo_fi)
_reg("TRIX",_trix_ft,_trix_tl,_trix_pt,_trix_ta,_trix_tu,_trix_fi)
_reg("TSF",_tsf_ft,_tsf_tl,_tsf_pt,_tsf_ta,_tsf_tu,_tsf_fi)
_reg("ULTOSC",_ultosc_ft,_ultosc_tl,_ultosc_pt,_ultosc_ta,_ultosc_tu,_ultosc_fi)
_reg("BOP",_bop_ft,_bop_tl,_bop_pt,_bop_ta,_bop_tu,_bop_fi)
_reg("PLUS_DI",_plusdi_ft,_plusdi_tl,_plusdi_pt,_plusdi_ta,_plusdi_tu,_plusdi_fi)
_reg("MINUS_DI",_minusdi_ft,_minusdi_tl,_minusdi_pt,_minusdi_ta,_minusdi_tu,_minusdi_fi)
_reg("BBANDS",_bb_ft,_bb_tl,_bb_pt,_bb_ta,_bb_tu,_bb_fi)
_reg("ATR",_atr_ft,_atr_tl,_atr_pt,_atr_ta,_atr_tu,_atr_fi)
_reg("NATR",_natr_ft,_natr_tl,_natr_pt,_natr_ta,_natr_tu,_natr_fi)
_reg("TRANGE",_trange_ft,_trange_tl,_trange_pt,_trange_ta,_trange_tu,_trange_fi)
_reg("STDDEV",_stddev_ft,_stddev_tl,_stddev_pt,_stddev_ta,_stddev_tu,_stddev_fi)
_reg("VAR",_var_ft,_var_tl,_var_pt,_var_ta,_var_tu,_var_fi)
_reg("SAR",_sar_ft,_sar_tl,_sar_pt,_sar_ta,_sar_tu,_sar_fi)
_reg("KELTNER_CHANNELS",_kc_ft,_kc_tl,_kc_pt,_kc_ta,_kc_tu,_kc_fi)
_reg("DONCHIAN",_donchian_ft,_donchian_tl,_donchian_pt,_donchian_ta,_donchian_tu,_donchian_fi)
_reg("SUPERTREND",_supertrend_ft,_supertrend_tl,_supertrend_pt,_supertrend_ta,_supertrend_tu,_supertrend_fi)
_reg("CHOPPINESS_INDEX",_chop_ft,_chop_tl,_chop_pt,_chop_ta,_chop_tu,_chop_fi)
_reg("OBV",_obv_ft,_obv_tl,_obv_pt,_obv_ta,_obv_tu,_obv_fi)
_reg("AD",_ad_ft,_ad_tl,_ad_pt,_ad_ta,_ad_tu,_ad_fi)
_reg("ADOSC",_adosc_ft,_adosc_tl,_adosc_pt,_adosc_ta,_adosc_tu,_adosc_fi)
_reg("MFI",_mfi_ft,_mfi_tl,_mfi_pt,_mfi_ta,_mfi_tu,_mfi_fi)
_reg("VWAP",_vwap_ft,_vwap_tl,_vwap_pt,_vwap_ta,_vwap_tu,_vwap_fi)
_reg("AVGPRICE",_avgprice_ft,_avgprice_tl,_avgprice_pt,_avgprice_ta,_avgprice_tu,_avgprice_fi)
_reg("MEDPRICE",_medprice_ft,_medprice_tl,_medprice_pt,_medprice_ta,_medprice_tu,_medprice_fi)
_reg("TYPPRICE",_typprice_ft,_typprice_tl,_typprice_pt,_typprice_ta,_typprice_tu,_typprice_fi)
_reg("WCLPRICE",_wclprice_ft,_wclprice_tl,_wclprice_pt,_wclprice_ta,_wclprice_tu,_wclprice_fi)
_reg("SQRT",_sqrt_ft,_sqrt_tl,_sqrt_pt,_sqrt_ta,_sqrt_tu,_sqrt_fi)
_reg("LOG10",_log10_ft,_log10_tl,_log10_pt,_log10_ta,_log10_tu,_log10_fi)
_reg("ADD",_add_ft,_add_tl,_add_pt,_add_ta,_add_tu,_add_fi)
_reg("LINEARREG",_linearreg_ft,_linearreg_tl,_linearreg_pt,_linearreg_ta,_linearreg_tu,_linearreg_fi)
_reg("LINEARREG_SLOPE",_linreg_slope_ft,_linreg_slope_tl,_linreg_slope_pt,_linreg_slope_ta,_linreg_slope_tu,_linreg_slope_fi)
_reg("CORREL",_correl_ft,_correl_tl,_correl_pt,_correl_ta,_correl_tu,_correl_fi)
_reg("BETA",_beta_ft,_beta_tl,_beta_pt,_beta_ta,_beta_tu,_beta_fi)
_reg("HT_DCPERIOD",_ht_dcperiod_ft,_ht_dcperiod_tl,_ht_dcperiod_pt,_ht_dcperiod_ta,_ht_dcperiod_tu,_ht_dcperiod_fi)
_reg("HT_TRENDMODE",_ht_trendmode_ft,_ht_trendmode_tl,_ht_trendmode_pt,_ht_trendmode_ta,_ht_trendmode_tu,_ht_trendmode_fi)
_reg("CDLENGULFING",_cdlengulfing_ft,_cdlengulfing_tl,_cdlengulfing_pt,_cdlengulfing_ta,_cdlengulfing_tu,_cdlengulfing_fi)
_reg("CDLDOJI",_cdldoji_ft,_cdldoji_tl,_cdldoji_pt,_cdldoji_ta,_cdldoji_tu,_cdldoji_fi)
_reg("CDLHAMMER",_cdlhammer_ft,_cdlhammer_tl,_cdlhammer_pt,_cdlhammer_ta,_cdlhammer_tu,_cdlhammer_fi)

# ============================================================
# METADATA
# ============================================================
INDICATOR_DEFAULTS: dict[str, dict] = {
    "SMA":{"timeperiod":20},"EMA":{"timeperiod":20},"WMA":{"timeperiod":14},
    "DEMA":{"timeperiod":20},"TEMA":{"timeperiod":20},"T3":{"timeperiod":5},
    "TRIMA":{"timeperiod":20},"KAMA":{"timeperiod":10},"HULL_MA":{"timeperiod":16},
    "VWMA":{"timeperiod":20},"MIDPOINT":{"timeperiod":14},"MIDPRICE":{"timeperiod":14},
    "RSI":{"timeperiod":14},
    "MACD":{"fastperiod":12,"slowperiod":26,"signalperiod":9},
    "STOCH":{"fastk_period":14,"slowk_period":3,"slowd_period":3},
    "CCI":{"timeperiod":14},"WILLR":{"timeperiod":14},
    "AROON":{"timeperiod":14},"AROONOSC":{"timeperiod":14},
    "ADX":{"timeperiod":14},"MOM":{"timeperiod":10},"ROC":{"timeperiod":10},
    "CMO":{"timeperiod":14},"PPO":{"fastperiod":12,"slowperiod":26},
    "TRIX":{"timeperiod":18},"TSF":{"timeperiod":14},
    "ULTOSC":{"timeperiod1":7,"timeperiod2":14,"timeperiod3":28},
    "BOP":{},"PLUS_DI":{"timeperiod":14},"MINUS_DI":{"timeperiod":14},
    "BBANDS":{"timeperiod":20,"nbdevup":2.0,"nbdevdn":2.0},
    "ATR":{"timeperiod":14},"NATR":{"timeperiod":14},"TRANGE":{},
    "STDDEV":{"timeperiod":20},"VAR":{"timeperiod":20},
    "SAR":{"acceleration":0.02,"maximum":0.2},
    "KELTNER_CHANNELS":{"timeperiod":20},"DONCHIAN":{"timeperiod":20},
    "SUPERTREND":{"timeperiod":7},"CHOPPINESS_INDEX":{"timeperiod":14},
    "OBV":{},"AD":{},"ADOSC":{"fastperiod":3,"slowperiod":10},
    "MFI":{"timeperiod":14},"VWAP":{},
    "AVGPRICE":{},"MEDPRICE":{},"TYPPRICE":{},"WCLPRICE":{},
    "SQRT":{},"LOG10":{},"ADD":{},
    "LINEARREG":{"timeperiod":14},"LINEARREG_SLOPE":{"timeperiod":14},
    "CORREL":{"timeperiod":30},"BETA":{"timeperiod":5},
    "HT_DCPERIOD":{},"HT_TRENDMODE":{},
    "CDLENGULFING":{},"CDLDOJI":{},"CDLHAMMER":{},
}

INDICATOR_NAMES = list(INDICATOR_DEFAULTS.keys())
LIBRARY_NAMES   = ["ferro_ta","talib","pandas_ta","ta","tulipy","finta"]

INDICATOR_CATEGORIES: dict[str, list[str]] = {
    "Overlap":         ["SMA","EMA","WMA","DEMA","TEMA","T3","TRIMA","KAMA","HULL_MA","VWMA","MIDPOINT","MIDPRICE"],
    "Momentum":        ["RSI","MACD","STOCH","CCI","WILLR","AROON","AROONOSC","ADX","MOM","ROC","CMO","PPO","TRIX","TSF","ULTOSC","BOP","PLUS_DI","MINUS_DI"],
    "Volatility":      ["BBANDS","ATR","NATR","TRANGE","STDDEV","VAR","SAR","KELTNER_CHANNELS","DONCHIAN","SUPERTREND","CHOPPINESS_INDEX"],
    "Volume":          ["OBV","AD","ADOSC","MFI","VWAP"],
    "Price Transform": ["AVGPRICE","MEDPRICE","TYPPRICE","WCLPRICE"],
    "Math":            ["SQRT","LOG10","ADD"],
    "Statistics":      ["LINEARREG","LINEARREG_SLOPE","CORREL","BETA"],
    "Cycle":           ["HT_DCPERIOD","HT_TRENDMODE"],
    "Pattern":         ["CDLENGULFING","CDLDOJI","CDLHAMMER"],
}

# Cumulative: compare first-differences not absolute values
CUMULATIVE_INDICATORS = {"OBV","AD","ADOSC"}
# Binary output: use agreement rate not allclose
BINARY_INDICATORS     = {"CDLENGULFING","CDLDOJI","CDLHAMMER","HT_TRENDMODE"}


def execute_indicator(library, indicator, data, df=None, **kwargs):
    """Run indicator from library on data dict, return 1-D float64 array."""
    if library not in available_libraries():
        raise KeyError(f"Library not available in this environment: {library!r}")

    key = (library, indicator)
    if key not in REGISTRY:
        raise KeyError(f"No wrapper for {key!r}")
    if df is None:
        from benchmarks.data_generator import get_pandas_ohlcv
        df = get_pandas_ohlcv(data)
    params = {**INDICATOR_DEFAULTS.get(indicator, {}), **kwargs}
    return REGISTRY[key](data, df, **params)