Update app.py

app.py

@@ -29,6 +29,7 @@ RR_GRID = [1.0, 1.25, 1.5, 2.0, 2.5, 3.0, 4.0]
 CLASSES = [-1, 0, 1]
 SIDE_MODES = ["Long + Short", "Sadece Long", "Sadece Short"]
 IND_MODES = ["Kapalı", "Onay filtresi (KNN + ST/UT)", "Sadece indikatör"]
+COMBO_MODES = ["Kapalı", "Onay filtresi (KNN + birleşik)", "Sadece birleşik sinyal"]
 LDC_MODES = ["Kapalı", "Onay filtresi (Lorentzian)", "Sadece Lorentzian"]
 VP_MODES = ["Kapalı", "Onay filtresi (POC / Value Area)", "KNN özelliği + onay filtresi"]
 
@@ -405,13 +406,23 @@ def calibrate_current(raw_cal, y_cal, raw_cur, classes):
 
 
 # ---------------------------------------------------------------- bariyer / R
+def stop_dist(A, i, side, sl_atr):
+    return A["ind_sd"][side][i] if "ind_sd" in A else sl_atr*A["a"][i]
+
+
 def barrier_trade(A, i, side, sl_atr, rr, h):
     """(getiri, çıkış_pozisyonu, neden) döndürür. Aynı mumda SL+TP varsa SL kabul edilir."""
     entry, av = A["c"][i], A["a"][i]
     if not np.isfinite(av) or av <= 0 or not np.isfinite(entry):
         return None
-    sd = sl_atr*av
-    td = sd*rr
+    if "ind_sd" in A:   # SL/TP indikatör seviyelerinden (ST / UT / Volume Profile)
+        sd = A["ind_sd"][side][i]
+        if not np.isfinite(sd) or sd <= 0:
+            return None
+        td = min(sd*rr, A["ind_cap"][side][i])
+    else:
+        sd = sl_atr*av
+        td = sd*rr
     end = min(i+h, len(A["c"])-1)
     for j in range(i+1, end+1):
         hi, lo = A["h"][j], A["l"][j]
@@ -434,7 +445,7 @@ def optimize_barriers(A, pos, regimes_arr, side, cost, current_regime, h):
     else:
         used = str(current_regime)
     results = []
-    for sl in SL_GRID:
+    for sl in ([1.0] if "ind_sd" in A else SL_GRID):
         for rr in RR_GRID:
             vals = []
             for i in sel:
@@ -542,7 +553,7 @@ TRADE_COLS = ["entry_date", "exit_date", "side", "entry_price", "exit_reason",
 
 # ---------------------------------------------------------------- grafikler
 def price_figure(df, ticker, trades_df, trade_ok, stop, target, ind=None, vp=None, vp_prof=None,
-                 ldc=None):
+                 ldc=None, combo=None):
     w = df.tail(150)
     sub = vp is not None and vp_prof is not None
     if sub:
@@ -595,6 +606,16 @@ def price_figure(df, ticker, trades_df, trade_ok, stop, target, ind=None, vp=Non
                 fig.add_trace(go.Scatter(x=w.index[m_], y=w[ycol].to_numpy()[m_]*off, mode="markers",
                                          name=nm, marker=dict(symbol="diamond", size=8, color=col,
                                                               line=dict(width=1, color="white"))), **kw)
+    if combo is not None:
+        cs = np.asarray(combo)[-150:]
+        pv = np.r_[0, cs[:-1]]
+        for d, nm, col, ycol, off in [(1, "Birleşik LONG", "#f59e0b", "Low", 0.985),
+                                      (-1, "Birleşik SHORT", "#7c3aed", "High", 1.015)]:
+            m_ = (cs == d) & (pv != d)
+            if m_.any():
+                fig.add_trace(go.Scatter(x=w.index[m_], y=w[ycol].to_numpy()[m_]*off, mode="markers",
+                                         name=nm, marker=dict(symbol="star", size=12, color=col,
+                                                              line=dict(width=1, color="white"))), **kw)
     if len(trades_df):
         t = trades_df[trades_df.entry_date.isin(w.index)]
         for side, sym, nm in [("LONG", "triangle-up", "OOS long"),
@@ -678,7 +699,8 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
                skip_overlap, whole_units, ind_mode, st_period, st_mult, ut_key, ut_period,
                vp_mode, vp_window, vp_bins, vp_va, vp_ext,
                ldc_mode, ldc_k, ldc_back, ldc_regime, ldc_kern_lb, ldc_kern_rw,
-               ldc_use_vol, ldc_use_regime, ldc_use_adx, ldc_kernel, ldc_exact):
+               ldc_use_vol, ldc_use_regime, ldc_use_adx, ldc_kernel, ldc_exact,
+               combo_mode, combo_votes, ind_tpsl, tpsl_smin, tpsl_smax, tpsl_minrr):
     try:
         ticker = str(ticker).strip().upper()
         h = int(horizon)
@@ -733,17 +755,51 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
         ind_confirm = ind_mode == IND_MODES[1]
         ind_now = int(ind_arr[-1])
 
-        # --- Lorentzian Classification (ML + kernel), tamamen Python'da
-        ldc_on = ldc_mode != LDC_MODES[0]
-        ldc_only = ldc_mode == LDC_MODES[2]
-        ldc_confirm = ldc_mode == LDC_MODES[1]
+        # --- Lorentzian Classification (ML + kernel) ve birleşik sinyal (oylama)
+        combo_on = combo_mode != COMBO_MODES[0]
+        combo_only = combo_mode == COMBO_MODES[2]
+        ldc_on = ldc_mode != LDC_MODES[0] and not combo_only
+        ldc_only = ldc_mode == LDC_MODES[2] and not combo_only
+        ldc_confirm = ldc_mode == LDC_MODES[1] and not combo_only
+        if combo_only:   # oylar zaten birleşik sinyale girer; tekil filtreler çift sayılmasın
+            ind_only = ind_confirm = vp_on = False
         ind_only = ind_only and not ldc_only      # iki "Sadece" modu birlikteyse Lorentzian öncelikli
+        need_ldc = ldc_mode != LDC_MODES[0] or combo_on
         LD = ldc_classify(df, ldc_k, ldc_back, ldc_regime, ldc_kern_lb, ldc_kern_rw,
                           use_vol=bool(ldc_use_vol), use_regime=bool(ldc_use_regime),
                           use_adx=bool(ldc_use_adx), use_kernel=bool(ldc_kernel),
-                          exact=bool(ldc_exact)) if ldc_on else None
+                          exact=bool(ldc_exact)) if need_ldc else None
         ldc_arr = LD["state"] if LD else np.zeros(len(df), dtype=int)
         ldc_now = int(ldc_arr[-1])
+        vp_now = int(vp_arr[-1])
+        votes = np.vstack([ind_arr, ldc_arr, vp_arr])     # ST+UT, Lorentzian, Volume Profile
+        n_long, n_short = (votes == 1).sum(axis=0), (votes == -1).sum(axis=0)
+        mv = int(combo_votes)
+        combo_arr = np.where((n_long >= mv) & (n_short == 0), 1,
+                             np.where((n_short >= mv) & (n_long == 0), -1, 0)).astype(int)
+        combo_now = int(combo_arr[-1])
+
+        # --- indikatör bazlı SL/TP: en yakın ST / UT / VP seviyesi = invalidasyon (SL),
+        #     önündeki Value Area / POC seviyesi >= 1 ATR uzaktaysa TP üst sınırı
+        ind_tpsl = bool(ind_tpsl)
+        if ind_tpsl:
+            c_, a_ = A["c"], A["a"]
+            vpo, vpl, vph = (vp[k].to_numpy(float) for k in ("poc", "val", "vah"))
+
+            def nearest(levels, sign):   # sign=+1: seviye fiyatın altında, -1: üstünde
+                d = np.full(len(c_), np.inf)
+                for lv in levels:
+                    dd = sign*(c_-lv)
+                    ok = np.isfinite(dd) & (dd > 0)
+                    d = np.where(ok & (dd < d), dd, d)
+                return d
+            smin, smax = float(tpsl_smin), float(tpsl_smax)
+            sd_of = lambda d: np.clip(np.where(np.isfinite(d), d+0.1*a_, 1.5*a_), smin*a_, smax*a_)
+            cap_of = lambda d: np.where(d >= 1.0*a_, d, np.inf)
+            A["ind_sd"] = {1: sd_of(nearest([st_line, ut_stop, vpl], 1)),
+                           -1: sd_of(nearest([st_line, ut_stop, vph], -1))}
+            A["ind_cap"] = {1: cap_of(nearest([vpo, vph], -1)),
+                            -1: cap_of(nearest([vpo, vpl], 1))}
 
         # --- K seçimi, kalibrasyon, güncel olasılık
         best_k, k_scores = tune_k(dev_X, dev_y, h)
@@ -770,6 +826,8 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
             side = ind_now
         if ldc_only and ldc_now != 0 and allow[ldc_now]:
             side = ldc_now
+        if combo_only and combo_now != 0 and allow[combo_now]:
+            side = combo_now
         p_side, p_opp = (p_up, p_down) if side == 1 else (p_down, p_up)
 
         imp, scaler = cal_model.named_steps["imputer"], cal_model.named_steps["scale"]
@@ -780,6 +838,8 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
             agreement = float((ind_arr[-10:] == side).mean())
         if ldc_only:
             agreement = float((ldc_arr[-10:] == side).mean())
+        if combo_only:
+            agreement = float((combo_arr[-10:] == side).mean())
 
         # --- yön bazlı TP/SL optimizasyonu (yalnızca geliştirme verisi)
         current_regime = str(regimes_all.iloc[-1])
@@ -792,6 +852,8 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
                 f_ = [i for i in f_ if ind_arr[i] == s_]
             if ldc_on:
                 f_ = [i for i in f_ if ldc_arr[i] == s_]
+            if combo_on:
+                f_ = [i for i in f_ if combo_arr[i] == s_]
             if vp_on:
                 f_ = [i for i in f_ if vp_arr[i] == s_]
             return f_ if len(f_) >= 35 else dev_pos
@@ -815,6 +877,10 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
             oos_pred = ldc_arr[oos_pos_arr]
             oos_bacc = float(balanced_accuracy_score(oos_y, oos_pred))
             oos_acc = float(accuracy_score(oos_y, oos_pred))
+        if combo_only:  # birleşik sinyal OOS'ta tahmin yerine geçer
+            oos_pred = combo_arr[oos_pos_arr]
+            oos_bacc = float(balanced_accuracy_score(oos_y, oos_pred))
+            oos_acc = float(accuracy_score(oos_y, oos_pred))
         if ind_only:  # indikatör yönü OOS'ta tahmin yerine geçer
             oos_pred = ind_arr[oos_pos_arr]
             oos_bacc = float(balanced_accuracy_score(oos_y, oos_pred))
@@ -831,6 +897,8 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
                 continue
             if ldc_confirm and ldc_arr[i] != pred:
                 continue
+            if combo_on and combo_arr[i] != pred:
+                continue
             if skip_overlap and i <= busy:
                 continue
             sl_p, rr_p = params[pred]
@@ -839,7 +907,7 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
                 continue
             ret, j, why = t
             net = ret-cost
-            r = net/max(sl_p*A["a"][i]/A["c"][i], 1e-12)
+            r = net/max(stop_dist(A, i, pred, sl_p)/A["c"][i], 1e-12)
             rows.append((df.index[i], df.index[j], "LONG" if pred == 1 else "SHORT",
                          A["c"][i], why, net*100, r, reg_arr[i]))
             busy = j
@@ -857,7 +925,17 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
 
         # --- güncel seviyeler ve pozisyon
         entry, cur_atr = float(df.Close.iloc[-1]), float(atr_all.iloc[-1])
-        stop_d, target_d = sl*cur_atr, sl*cur_atr*rr
+        if ind_tpsl:
+            stop_d = float(A["ind_sd"][side][-1])
+            target_d = float(min(stop_d*rr, A["ind_cap"][side][-1]))
+            cl_ = float(A["c"][-1])
+            cands = {"Supertrend": float(st_line[-1]), "UT trailing stop": float(ut_stop[-1]),
+                     "VP " + ("VAL" if side == 1 else "VAH"):
+                         float((vp.val if side == 1 else vp.vah).iloc[-1])}
+            valid = {k_: side*(cl_-v_) for k_, v_ in cands.items() if np.isfinite(v_) and side*(cl_-v_) > 0}
+            sl_name = min(valid, key=valid.get) if valid else "ATR varsayılan (seviye yok)"
+        else:
+            stop_d, target_d = sl*cur_atr, sl*cur_atr*rr
         stop = entry-stop_d if side == 1 else entry+stop_d
         target = entry+target_d if side == 1 else entry-target_d
 
@@ -887,7 +965,7 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
         ]
         dname = {1: "LONG ↑", -1: "SHORT ↓", 0: "belirsiz"}
         ind_check = ("İndikatör yönü (ST + UT aynı)", dname[ind_now], "yönle aynı", ind_now == side)
-        if ind_only or ldc_only:
+        if ind_only or ldc_only or combo_only:
             keep = ("Yön izni", "OOS balanced acc.", "OOS işlem sayısı", "OOS expectancy")
             checks = [c for c in checks if c[0] in keep]
         if ind_only or ind_confirm:
@@ -895,6 +973,15 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
         if ldc_on:
             checks.insert(1, ("Lorentzian yönü (ML + kernel)", dname[ldc_now], "yönle aynı",
                               ldc_now == side))
+        if combo_on:
+            nv = int(sum(1 for v_ in (ind_now, ldc_now, vp_now) if v_ == side))
+            no_ = int(sum(1 for v_ in (ind_now, ldc_now, vp_now) if v_ == -side))
+            checks.insert(1, ("Birleşik sinyal (ST+UT · Lorentzian · VP)", f"{nv}/3 oy, karşı {no_}",
+                              f"≥ {mv} oy, karşı oy yok", combo_now == side))
+        if ind_tpsl:
+            rr_now = target_d/stop_d if stop_d > 0 else 0.0
+            checks.append(("İndikatör R:R (TP/SL)", f"{rr_now:.2f}", f"≥ {float(tpsl_minrr):g}",
+                           rr_now >= float(tpsl_minrr)))
         if vp_on:
             checks.insert(1, ("Volume Profile (POC/VA konumu)", vp_names[int(vp_arr[-1])],
                               "yönle aynı", int(vp_arr[-1]) == side))
@@ -964,6 +1051,23 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
                         f"({int(ldc_kern_lb)}, {float(ldc_kern_rw):g}) · rejim eşiği {float(ldc_regime):g}.")
         else:
             ldc_md, ldc_note = "_Mod kapalı._", ""
+        if combo_on:
+            combo_md = md_table(["Kaynak", "Oy"], [
+                ("Supertrend + UT Bot", dname[ind_now]), ("Lorentzian (ML + kernel)", dname[ldc_now]),
+                ("Volume Profile (POC/VA)", dname[vp_now]),
+                ("**Birleşik sinyal**", f"**{dname[combo_now]}** (en az {mv} oy, karşı oy yok)")])
+        else:
+            combo_md = "_Mod kapalı._"
+        if ind_tpsl:
+            capped = target_d < stop_d*rr-1e-12
+            tp_title = "indikatörlerden türetildi"
+            tpsl_note = (f"SL: en yakın invalidasyon seviyesi — **{sl_name}** (+0,1 ATR tampon, "
+                         f"{float(tpsl_smin):g}–{float(tpsl_smax):g} ATR aralığına sıkıştırılır). "
+                         f"TP: {rr:.2f}R katı"
+                         + (", önündeki Value Area/POC seviyesinde sınırlandı" if capped else "")
+                         + ". Optimize edilen tek parametre R katıdır.\n\n")
+        else:
+            tp_title, tpsl_note = "optimize", ""
         k_text = " | ".join(f"K={k}: {s:.3f}" for s, k in sorted(k_scores, reverse=True)) or "—"
         overlap_note = ("tek pozisyon (çakışma yok)" if skip_overlap
                         else "çakışan sinyaller bağımsız işlem sayıldı")
@@ -988,6 +1092,9 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
 ## İndikatörler — mod: {ind_mode}
 {ind_md}
 
+## Birleşik sinyal — mod: {combo_mode}
+{combo_md}
+
 ## Lorentzian Classification — mod: {ldc_mode}
 {ldc_md}
 
@@ -998,16 +1105,16 @@ def run_engine(ticker, period, horizon, side_mode, equity, min_risk, max_risk,
 
 {vp_note}
 
-## TP / SL ({'LONG' if side == 1 else 'SHORT'} için optimize)
+## TP / SL ({'LONG' if side == 1 else 'SHORT'} için {tp_title})
 | Parametre | Değer |
 |---|---:|
-| SL | {sl:.2f} ATR |
-| TP | {rr:.2f}R |
+| SL | {stop_d/cur_atr:.2f} ATR |
+| TP | {target_d/stop_d:.2f}R |
 | Stop-loss | {fmt_p(stop)} |
 | Take-profit | {fmt_p(target)} |
 | ATR(14) | {fmt_p(cur_atr)} |
 
-TP/SL optimizasyon rejimi: {regime_used}. Yeterli rejim örneği yoksa tüm geliştirme dönemine geri dönülür.
+{tpsl_note}TP/SL optimizasyon rejimi: {regime_used}. Yeterli rejim örneği yoksa tüm geliştirme dönemine geri dönülür.
 
 ## OOS backtest ({overlap_note})
 {oos_md}
@@ -1034,6 +1141,8 @@ TP/SL optimizasyon rejimi: {regime_used}. Yeterli rejim örneği yoksa tüm geli
 """
         top_df = pd.DataFrame(top, columns=["score", "SL_ATR", "TP_R", "samples",
                                             "mean_net_return", "win_rate"])
+        if ind_tpsl and not top_df.empty:
+            top_df["SL_ATR"] = "indikatör"
         if not top_df.empty:
             top_df["score"] = top_df.score.map(lambda v: f"{v:.5f}")
             top_df["mean_net_return"] = top_df.mean_net_return.map(lambda v: f"{v:.3%}")
@@ -1047,8 +1156,8 @@ TP/SL optimizasyon rejimi: {regime_used}. Yeterli rejim örneği yoksa tüm geli
 
         price_fig = price_figure(df, ticker, trades_df, trade_ok, stop, target,
                                  ind=(st_line, st_dir, ut_stop),
-                                 vp=vp if vp_on else None, vp_prof=lp,
-                                 ldc=LD)
+                                 vp=vp if (vp_on or combo_on) else None, vp_prof=lp,
+                                 ldc=LD, combo=combo_arr if combo_on else None)
         eq_fig = equity_figure(curve, dds) if len(R) else None
         pf_fig = pf_gauge(stats["pf"], stats["n"]) if stats else None
         mc_fig = mc_figure(mc) if mc else None
@@ -1064,7 +1173,7 @@ TP/SL optimizasyon rejimi: {regime_used}. Yeterli rejim örneği yoksa tüm geli
             "seri korelasyonunu ve rejim değişimini tam modellemez. Pozisyon hesabı spot miktar "
             "varsayar; CFD lot sözleşmesi, spread, funding, swap, komisyon, minimum lot, marjin ve "
             "broker fiyatı farklı olabilir. Gap ve kayma kaybı planlanan riskin üstüne çıkarabilir. "
-            "Supertrend ve UT Bot, TradingView formüllerinin Python portudur; ATR başlangıcı ve veri kaynağı yüzünden TV değerlerinden küçük sapmalar olabilir. Lorentzian Classification, jdehorty'nin TradingView göstergesinin Python portudur (ANN komşu seçimi, filtreler ve kernel regresyon); Pine kaynağıyla birebir aynı sonuç vermeyebilir ve yalnızca günlük mumda çalışır. Volume Profile, günlük OHLCV'den (her mumun hacmi high–low aralığına eşit dağıtılarak) yaklaşık hesaplanır; TradingView VPVR'nin alt-zaman dilimi verisiyle birebir aynı olmaz. Canlı hesap öncesi paper trading ve broker bazlı doğrulama zorunludur."
+            "Supertrend ve UT Bot, TradingView formüllerinin Python portudur; ATR başlangıcı ve veri kaynağı yüzünden TV değerlerinden küçük sapmalar olabilir. Birleşik sinyal; ST+UT, Lorentzian ve Volume Profile oylarının birleşimidir. İndikatör bazlı TP/SL, en yakın ST/UT/VP seviyesini invalidasyon sayar ve ATR aralığına sıkıştırır. Lorentzian Classification, jdehorty'nin TradingView göstergesinin Python portudur (ANN komşu seçimi, filtreler ve kernel regresyon); Pine kaynağıyla birebir aynı sonuç vermeyebilir ve yalnızca günlük mumda çalışır. Volume Profile, günlük OHLCV'den (her mumun hacmi high–low aralığına eşit dağıtılarak) yaklaşık hesaplanır; TradingView VPVR'nin alt-zaman dilimi verisiyle birebir aynı olmaz. Canlı hesap öncesi paper trading ve broker bazlı doğrulama zorunludur."
         )
         return (report, prob_figure(p_down, p_flat, p_up), price_fig, eq_fig, pf_fig, mc_fig,
                 top_df, csv_path, disclaimer)
@@ -1092,6 +1201,9 @@ with gr.Blocks(title=APP_TITLE, theme=gr.themes.Soft()) as demo:
             ind_mode = gr.Radio(IND_MODES, value="Kapalı", label="İndikatör modu (Supertrend + UT Bot)")
             vp_mode = gr.Radio(VP_MODES, value="Kapalı", label="Volume Profile modu")
             ldc_mode = gr.Radio(LDC_MODES, value="Kapalı", label="Lorentzian Classification modu")
+            combo_mode = gr.Radio(COMBO_MODES, value=COMBO_MODES[2],
+                                  label="Birleşik sinyal (ST+UT · Lorentzian · Volume Profile oylaması)")
+            ind_tpsl = gr.Checkbox(value=True, label="TP/SL'i indikatörlerden türet (ST / UT / VP seviyeleri)")
             train_window = gr.Slider(300, 1500, value=900, step=50, label="Maksimum eğitim penceresi")
         with gr.Column():
             equity = gr.Number(value=10000, label="Hesap büyüklüğü (USD)")
@@ -1114,6 +1226,11 @@ with gr.Blocks(title=APP_TITLE, theme=gr.themes.Soft()) as demo:
             st_mult = gr.Slider(1.0, 6.0, value=3.0, step=0.1, label="Supertrend çarpanı")
             ut_key = gr.Slider(0.5, 4.0, value=1.0, step=0.1, label="UT Bot key value")
             ut_period = gr.Slider(5, 30, value=10, step=1, label="UT Bot ATR periyodu")
+        with gr.Row():
+            combo_votes = gr.Slider(1, 3, value=2, step=1, label="Birleşik sinyal: min. aynı yön oyu (karşı oy yok)")
+            tpsl_smin = gr.Slider(0.3, 2.0, value=0.8, step=0.1, label="İndikatör SL alt sınır (ATR)")
+            tpsl_smax = gr.Slider(1.5, 6.0, value=3.0, step=0.1, label="İndikatör SL üst sınır (ATR)")
+            tpsl_minrr = gr.Slider(0.5, 3.0, value=1.0, step=0.1, label="Min. R:R (kapı)")
         with gr.Row():
             ldc_k = gr.Slider(1, 30, value=8, step=1, label="Lorentzian komşu sayısı")
             ldc_back = gr.Slider(300, 3000, value=2000, step=100, label="Lorentzian maks. geçmiş mum")
@@ -1162,7 +1279,8 @@ with gr.Blocks(title=APP_TITLE, theme=gr.themes.Soft()) as demo:
                 skip_overlap, whole_units, ind_mode, st_period, st_mult, ut_key, ut_period,
                 vp_mode, vp_window, vp_bins, vp_va, vp_ext,
                 ldc_mode, ldc_k, ldc_back, ldc_regime, ldc_kern_lb, ldc_kern_rw,
-                ldc_use_vol, ldc_use_regime, ldc_use_adx, ldc_kernel, ldc_exact],
+                ldc_use_vol, ldc_use_regime, ldc_use_adx, ldc_kernel, ldc_exact,
+                combo_mode, combo_votes, ind_tpsl, tpsl_smin, tpsl_smax, tpsl_minrr],
         outputs=[output, prob_plot, chart, equity_plot, pf_plot, mc_plot, optimization,
                  csv_file, disclaimer],
     )