Update app.py

app.py

@@ -53,35 +53,29 @@ def get_strategy_presets():
 
 strategy_presets = get_strategy_presets()
 
-# === CORE SIMULATION ENGINE ===
+# === CORE SIMULATION ===
 def simulate_tp_strategy_full(starting_balance, trades_min, trades_max, weeks,
                               tp1_prob, tp2_prob, tp1_r, tp2_r, base_risk_pct,
                               profit_target=None, fatigue=0.0, trump_vol=0.0):
     if tp1_prob + tp2_prob >= 1.0:
         return pd.DataFrame(), {"Error": "Invalid probability config. TP1 + TP2 must be < 1.0"}
-
+    
     sl_prob = 1.0 - tp1_prob - tp2_prob
-    balance = starting_balance
-    peak = balance
-    drawdown = 0
+    balance, peak, drawdown = starting_balance, starting_balance, 0
     tp1_hits = tp2_hits = sl_hits = 0
-    max_win_streak = max_loss_streak = 0
-    cur_win_streak = cur_loss_streak = 0
-    log = []
-
+    max_win_streak = max_loss_streak = cur_win_streak = cur_loss_streak = 0
     fatigue_multiplier = 1.0 - fatigue * 0.4
     trump_vol_factor = np.random.normal(1.0, 0.2 * trump_vol)
+    log = []
 
     for week in range(1, weeks + 1):
-        if profit_target and balance >= profit_target:
-            break
+        if profit_target and balance >= profit_target: break
         week_start = balance
         num_trades = np.random.randint(trades_min, trades_max + 1)
+
         for _ in range(num_trades):
-            risk_pct = base_risk_pct
-            risk_amount = balance * risk_pct * np.random.uniform(0.9, 1.1)
+            risk_amount = balance * base_risk_pct * np.random.uniform(0.9, 1.1)
             risk_amount *= trump_vol_factor
-
             if fatigue > 0.6 and cur_loss_streak >= 3 and np.random.rand() < fatigue * 0.25:
                 outcome = "SL"
             else:
@@ -108,19 +102,16 @@ def simulate_tp_strategy_full(starting_balance, trades_min, trades_max, weeks,
             peak = max(peak, balance)
             drawdown = max(drawdown, (peak - balance) / peak * 100)
 
-        weekly_return = (balance - week_start) / week_start * 100
         log.append({
             "Week": week, "Start Balance": round(week_start, 2),
             "End Balance": round(balance, 2),
-            "Weekly Return (%)": round(weekly_return, 2)
+            "Weekly Return (%)": round((balance - week_start) / week_start * 100, 2)
         })
 
     df = pd.DataFrame(log)
     returns = df["End Balance"].pct_change().dropna()
-    volatility = returns.std() * np.sqrt(52)
-    sharpe_ratio = returns.mean() / returns.std() * np.sqrt(52) if returns.std() > 0 else 0
+    sharpe = returns.mean() / returns.std() * np.sqrt(52) if returns.std() > 0 else 0
     score = balance / (1 + drawdown)
-
     summary = {
         "Final Balance": round(balance, 2),
         "TP1 Hits": tp1_hits,
@@ -129,271 +120,181 @@ def simulate_tp_strategy_full(starting_balance, trades_min, trades_max, weeks,
         "Max Drawdown %": round(drawdown, 2),
         "Max Win Streak": max_win_streak,
         "Max Loss Streak": max_loss_streak,
-        "Sharpe Ratio": round(sharpe_ratio, 2),
+        "Sharpe Ratio": round(sharpe, 2),
         "EdgeCast Score": round(score, 2)
     }
-    
     return df, summary
 
-# === HISTOGRAM SIMULATION (NEW) ===
-def simulate_multiple_runs(config, metric="EdgeCast Score", runs=100):
-    metric_values = []
-    for _ in range(runs):
-        _, summary = simulate_tp_strategy_full(
-            config["starting_balance"],
-            config["trades_min"],
-            config["trades_max"],
-            config["weeks"],
-            config["tp1_prob"],
-            config["tp2_prob"],
-            config["tp1_r"],
-            config["tp2_r"],
-            config["base_risk_pct"],
-            config["profit_target"],
-            config["fatigue"],
-            config["trump_vol"]
-        )
-        metric_values.append(summary[metric])
-    return pd.DataFrame({metric: metric_values})
-
-def plot_histogram(df, metric):
-    fig = px.histogram(df, x=metric, nbins=30, title=f"{metric} Distribution")
-    fig.update_layout(
-        xaxis_title=metric,
-        yaxis_title="Frequency",
-        bargap=0.1,
-        height=400
-    )
-    return fig
-# === PART 2: PLOTTING ===
-
+# === VISUALIZATION ===
 def equity_curve_plot(df, label="Equity Curve"):
     fig = go.Figure()
-    fig.add_trace(go.Scatter(
-        x=df["Week"],
-        y=df["End Balance"],
-        mode="lines+markers",
-        name=label
-    ))
-    fig.update_layout(
-        title=f"📈 {label}",
-        xaxis_title="Week",
-        yaxis_title="Balance ($)",
-        height=400
-    )
+    fig.add_trace(go.Scatter(x=df["Week"], y=df["End Balance"], mode="lines+markers", name=label))
+    fig.update_layout(title=f"📈 {label}", xaxis_title="Week", yaxis_title="Balance ($)", height=400)
     return fig
 
-
-def generate_histogram(metric="Final Balance"):
+def generate_histogram(metric="EdgeCast Score"):
     results = []
     for name, config in strategy_presets.items():
-        _, summary = simulate_tp_strategy_full(**{k: v for k, v in config.items() if k != "description"})
+        _, summary = simulate_tp_strategy_full(
+            config["starting_balance"], config["trades_min"], config["trades_max"], config["weeks"],
+            config["tp1_prob"], config["tp2_prob"], config["tp1_r"], config["tp2_r"],
+            config["base_risk_pct"], config["profit_target"], config["fatigue"], config["trump_vol"]
+        )
         summary["Strategy"] = name
         results.append(summary)
-
     df = pd.DataFrame(results)
 
-    if metric not in df.columns:
-        return go.Figure()
-
-    fig = px.histogram(
-        df,
-        x=metric,
-        color="Strategy",
-        barmode="overlay",
-        nbins=25,
-        title=f"📊 Histogram: {metric}",
-        labels={metric: metric}
-    )
-
-    fig.update_layout(
-        xaxis_title=metric,
-        yaxis_title="Frequency",
-        bargap=0.2
-    )
-
+    fig = px.histogram(df, x=metric, color="Strategy", marginal="box", opacity=0.7, barmode="overlay")
+    fig.update_layout(title=f"📊 {metric} Histogram", xaxis_title=metric, yaxis_title="Count", height=500)
     return fig
-# === PART 3: ANALYSIS TABS ===
 
-def show_descriptions():
-    return pd.DataFrame([
-        {"Strategy": name, "Description": config["description"]}
-        for name, config in strategy_presets.items()
-    ])
+def histogram_viewer_ui(metric):
+    return generate_histogram(metric)
 
+# === ANALYSIS TOOLS ===
 def analytics_dashboard(rank_by="EdgeCast Score"):
     results = []
     for name, config in strategy_presets.items():
         _, summary = simulate_tp_strategy_full(**{k: v for k, v in config.items() if k != "description"})
         summary["Strategy"] = name
         results.append(summary)
-
     df = pd.DataFrame(results)
-
     winner_vals = {
         "Final Balance": df["Final Balance"].max(),
         "Sharpe Ratio": df["Sharpe Ratio"].max(),
         "EdgeCast Score": df["EdgeCast Score"].max(),
         "Max Drawdown %": df["Max Drawdown %"].min()
     }
-
-    ascending = rank_by == "Max Drawdown %"
-    df = df.sort_values(rank_by, ascending=ascending).reset_index(drop=True)
+    df = df.sort_values(rank_by, ascending=(rank_by == "Max Drawdown %")).reset_index(drop=True)
     df.insert(0, "🏅 Rank", [f"#{i+1}" for i in df.index])
-
     for col in winner_vals:
-        df[col] = df[col].apply(lambda x: f"{round(x, 2)} 🏆" if x == winner_vals[col] else f"{round(x, 2)}")
-
+        df[col] = df[col].apply(lambda x: f"{round(x,2)} 🏆" if x == winner_vals[col] else f"{round(x,2)}")
     return df[["🏅 Rank", "Strategy", "Final Balance", "Sharpe Ratio", "EdgeCast Score", "Max Drawdown %"]]
 
+def show_descriptions():
+    return pd.DataFrame([{"Strategy": name, "Description": cfg["description"]} for name, cfg in strategy_presets.items()])
 
 def generate_risk_matrix():
     names = list(strategy_presets.keys())
-    scores = {
-        name: simulate_tp_strategy_full(**{k: v for k, v in cfg.items() if k != "description"})[1]["EdgeCast Score"]
-        for name, cfg in strategy_presets.items()
-    }
-    matrix = np.zeros((len(names), len(names)))
-    for i, a in enumerate(names):
-        for j, b in enumerate(names):
-            matrix[i, j] = abs(scores[a] - scores[b])
+    scores = {n: simulate_tp_strategy_full(**{k: v for k, v in cfg.items() if k != "description"})[1]["EdgeCast Score"] for n, cfg in strategy_presets.items()}
+    matrix = np.array([[abs(scores[a] - scores[b]) for b in names] for a in names])
+    fig = px.imshow(matrix, x=names, y=names, text_auto=".2f", color_continuous_scale="RdYlGn_r", labels={"color": "Δ Score"})
+    fig.update_layout(title="🧠 Risk Matrix (Score Δ)", height=600)
+    return fig
 
-    fig = px.imshow(
-        matrix,
-        x=names,
-        y=names,
-        text_auto=".2f",
-        color_continuous_scale="RdYlGn_r",
-        labels={"color": "Score Δ"},
-        title="🧠 Risk Matrix (Δ Score Heatmap)"
+# === STRATEGY RUNNERS ===
+def run_preset_strategy(style, fatigue=0.0, trump_vol=0.0):
+    config = strategy_presets[style]
+    df, summary = simulate_tp_strategy_full(
+        config["starting_balance"], config["trades_min"], config["trades_max"], config["weeks"],
+        config["tp1_prob"], config["tp2_prob"], config["tp1_r"], config["tp2_r"],
+        config["base_risk_pct"], config["profit_target"], fatigue, trump_vol
     )
-    fig.update_traces(
-        hovertemplate="<b>%{y}</b> vs <b>%{x}</b><br>Δ Score: %{z:.2f}<extra></extra>"
+    return df, summary, equity_curve_plot(df, style), config["description"]
+
+def run_manual_sim(starting_balance, trades_min, trades_max, weeks,
+                   tp1_prob, tp2_prob, tp1_r, tp2_r, base_risk_pct, profit_target,
+                   fatigue, trump_vol):
+    df, summary = simulate_tp_strategy_full(
+        starting_balance, trades_min, trades_max, weeks,
+        tp1_prob, tp2_prob, tp1_r, tp2_r, base_risk_pct,
+        profit_target, fatigue, trump_vol
+    )
+    return df, summary, equity_curve_plot(df, "Manual Config")
+
+def dual_manual_battle(
+    sb1, tmin1, tmax1, w1, tp1a, tp2a, r1a, r2a, risk1, pt1, fat1, trump1,
+    sb2, tmin2, tmax2, w2, tp1b, tp2b, r1b, r2b, risk2, pt2, fat2, trump2
+):
+    df1, s1 = simulate_tp_strategy_full(sb1, tmin1, tmax1, w1, tp1a, tp2a, r1a, r2a, risk1, pt1, fat1, trump1)
+    df2, s2 = simulate_tp_strategy_full(sb2, tmin2, tmax2, w2, tp1b, tp2b, r1b, r2b, risk2, pt2, fat2, trump2)
+    s1["Strategy"], s2["Strategy"] = "Manual A", "Manual B"
+    df_summary = pd.DataFrame([s1, s2])[["Strategy", "Final Balance", "Sharpe Ratio", "EdgeCast Score", "Max Drawdown %"]]
+    for col in ["Final Balance", "Sharpe Ratio", "EdgeCast Score"]:
+        best = df_summary[col].astype(float).max()
+        df_summary[col] = [f"{val} 🏆" if float(val) == best else val for val in df_summary[col]]
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=df1["Week"], y=df1["End Balance"], name="Manual A"))
+    fig.add_trace(go.Scatter(x=df2["Week"], y=df2["End Balance"], name="Manual B"))
+    fig.update_layout(title="⚔️ Manual Strategy Battle", xaxis_title="Week", yaxis_title="Balance")
+    return df_summary, fig
+
+def get_manual_battle_interface():
+    return gr.Interface(
+        fn=dual_manual_battle,
+        inputs=[
+            # A Config
+            gr.Slider(100, 20000, 2500, label="A: Start Balance"),
+            gr.Slider(1, 10, 3, label="A: Trades Min"),
+            gr.Slider(1, 15, 7, label="A: Trades Max"),
+            gr.Slider(1, 52, 12, label="A: Weeks"),
+            gr.Slider(0, 1, 0.3, step=0.05, label="A: TP1 %"),
+            gr.Slider(0, 1, 0.3, step=0.05, label="A: TP2 %"),
+            gr.Slider(0.1, 5.0, 1.0, step=0.1, label="A: TP1 R"),
+            gr.Slider(0.1, 20.0, 2.0, step=0.1, label="A: TP2 R"),
+            gr.Slider(0.001, 0.05, 0.01, step=0.001, label="A: Risk %"),
+            gr.Slider(0, 100000, 0, step=500, label="A: Profit Target"),
+            gr.Slider(0, 1, 0.0, step=0.1, label="A: Fatigue"),
+            gr.Slider(0, 1, 0.0, step=0.1, label="A: Trump Volatility"),
+            # B Config
+            gr.Slider(100, 20000, 2500, label="B: Start Balance"),
+            gr.Slider(1, 10, 3, label="B: Trades Min"),
+            gr.Slider(1, 15, 7, label="B: Trades Max"),
+            gr.Slider(1, 52, 12, label="B: Weeks"),
+            gr.Slider(0, 1, 0.3, step=0.05, label="B: TP1 %"),
+            gr.Slider(0, 1, 0.3, step=0.05, label="B: TP2 %"),
+            gr.Slider(0.1, 5.0, 1.0, step=0.1, label="B: TP1 R"),
+            gr.Slider(0.1, 20.0, 2.0, step=0.1, label="B: TP2 R"),
+            gr.Slider(0.001, 0.05, 0.01, step=0.001, label="B: Risk %"),
+            gr.Slider(0, 100000, 0, step=500, label="B: Profit Target"),
+            gr.Slider(0, 1, 0.0, step=0.1, label="B: Fatigue"),
+            gr.Slider(0, 1, 0.0, step=0.1, label="B: Trump Volatility")
+        ],
+        outputs=["dataframe", gr.Plot()],
+        title="🧪 Manual Strategy Battle"
     )
-    return fig
-
-
-def histogram_viewer_ui(metric):
-    return generate_histogram(metric)
-# === PART 4: GRADIO INTERFACE ===
 
+# === LAUNCH INTERFACE ===
 app = gr.TabbedInterface(
     interface_list=[
+        gr.Interface(fn=run_preset_strategy, inputs=[
+            gr.Dropdown(choices=list(strategy_presets.keys()), label="Select Strategy"),
+            gr.Slider(0, 1, 0.0, step=0.1, label="Fatigue Level"),
+            gr.Slider(0, 1, 0.0, step=0.1, label="Trump Volatility Index")
+        ], outputs=["dataframe", "json", gr.Plot(), "text"], title="🎯 Preset Mode"),
+
+        gr.Interface(fn=run_manual_sim, inputs=[
+            gr.Slider(100, 20000, 2500, label="Start Balance"),
+            gr.Slider(1, 10, 3, label="Trades Min"),
+            gr.Slider(1, 15, 7, label="Trades Max"),
+            gr.Slider(1, 52, 12, label="Weeks"),
+            gr.Slider(0, 1, 0.3, step=0.05, label="TP1 %"),
+            gr.Slider(0, 1, 0.3, step=0.05, label="TP2 %"),
+            gr.Slider(0.1, 5.0, 1.0, step=0.1, label="TP1 R"),
+            gr.Slider(0.1, 20.0, 2.0, step=0.1, label="TP2 R"),
+            gr.Slider(0.001, 0.05, 0.01, step=0.001, label="Risk %"),
+            gr.Slider(0, 100000, 0, step=500, label="Profit Target 💰"),
+            gr.Slider(0, 1, 0.0, step=0.1, label="Fatigue Level"),
+            gr.Slider(0, 1, 0.0, step=0.1, label="Trump Volatility Index")
+        ], outputs=["dataframe", "json", gr.Plot()], title="🛠️ Manual Config"),
 
-        # 🎯 Preset Strategy Tab
-        gr.Interface(
-            fn=run_preset_strategy,
-            inputs=[
-                gr.Dropdown(choices=list(strategy_presets.keys()), label="Select Strategy"),
-                gr.Slider(0, 1, 0.0, step=0.1, label="Fatigue Level"),
-                gr.Slider(0, 1, 0.0, step=0.1, label="Trump Volatility Index")
-            ],
-            outputs=["dataframe", "json", gr.Plot(), "text"],
-            title="🎯 Preset Strategy Mode"
-        ),
-
-        # 🛠️ Manual Config Tab
-        gr.Interface(
-            fn=run_manual_sim,
-            inputs=[
-                gr.Slider(100, 20000, 2500, label="Start Balance"),
-                gr.Slider(1, 10, 3, label="Trades Min"),
-                gr.Slider(1, 15, 7, label="Trades Max"),
-                gr.Slider(1, 52, 12, label="Weeks"),
-                gr.Slider(0, 1, 0.3, step=0.05, label="TP1 %"),
-                gr.Slider(0, 1, 0.3, step=0.05, label="TP2 %"),
-                gr.Slider(0.1, 5.0, 1.0, step=0.1, label="TP1 R"),
-                gr.Slider(0.1, 20.0, 2.0, step=0.1, label="TP2 R"),
-                gr.Slider(0.001, 0.05, 0.01, step=0.001, label="Risk %"),
-                gr.Slider(0, 100000, 0, step=500, label="Profit Target 💰"),
-                gr.Slider(0, 1, 0.0, step=0.1, label="Fatigue Level"),
-                gr.Slider(0, 1, 0.0, step=0.1, label="Trump Volatility Index")
-            ],
-            outputs=["dataframe", "json", gr.Plot()],
-            title="🛠️ Manual Config Mode"
-        ),
-
-        # 🧪 Manual Battle Tab
         get_manual_battle_interface(),
 
-        # 📊 Histogram Viewer
-        gr.Interface(
-            fn=histogram_viewer_ui,
-            inputs=gr.Dropdown(
-                choices=["Final Balance", "Sharpe Ratio", "EdgeCast Score", "Max Drawdown %"],
-                label="Select Metric"
-            ),
-            outputs=gr.Plot(),
-            title="📊 Histogram Viewer"
-        ),
+        gr.Interface(fn=histogram_viewer_ui, inputs=gr.Dropdown(
+            choices=["Final Balance", "Sharpe Ratio", "EdgeCast Score", "Max Drawdown %"],
+            label="Select Metric"
+        ), outputs=gr.Plot(), title="📊 Histogram Viewer"),
 
-        # 🏅 Leaderboard
-        gr.Interface(
-            fn=analytics_dashboard,
-            inputs=gr.Dropdown(
-                choices=["EdgeCast Score", "Final Balance", "Sharpe Ratio", "Max Drawdown %"],
-                value="EdgeCast Score",
-                label="Sort leaderboard by:"
-            ),
-            outputs="dataframe",
-            title="🏅 Strategy Leaderboard"
-        ),
+        gr.Interface(fn=analytics_dashboard, inputs=gr.Dropdown(
+            choices=["EdgeCast Score", "Final Balance", "Sharpe Ratio", "Max Drawdown %"],
+            label="Sort leaderboard by:"
+        ), outputs="dataframe", title="🏅 Leaderboard"),
 
-        # 📘 Descriptions
-        gr.Interface(
-            fn=show_descriptions,
-            inputs=[], outputs="dataframe",
-            title="📘 Strategy Descriptions"
-        ),
+        gr.Interface(fn=show_descriptions, inputs=[], outputs="dataframe", title="📘 Descriptions"),
 
-        # 🔬 Risk Matrix
-        gr.Interface(
-            fn=generate_risk_matrix,
-            inputs=[], outputs=gr.Plot(),
-            title="🔬 Risk Matrix"
-        )
+        gr.Interface(fn=generate_risk_matrix, inputs=[], outputs=gr.Plot(), title="🔬 Risk Matrix")
     ],
-    tab_names=["Preset", "Manual", "Battle", "Histogram", "Leaderboard", "Descriptions", "Risk Matrix"],
     title="EdgeCast – Strategy Simulation Suite"
 )
 
 app.launch()
-# === PART 5: HISTOGRAM VIEWER ENGINE ===
-
-def generate_histogram(metric="EdgeCast Score"):
-    results = []
-    for name, config in strategy_presets.items():
-        _, summary = simulate_tp_strategy_full(
-            config["starting_balance"], config["trades_min"], config["trades_max"], config["weeks"],
-            config["tp1_prob"], config["tp2_prob"], config["tp1_r"], config["tp2_r"],
-            config["base_risk_pct"], config["profit_target"], config["fatigue"], config["trump_vol"]
-        )
-        summary["Strategy"] = name
-        results.append(summary)
-
-    df = pd.DataFrame(results)
-
-    if metric not in df.columns:
-        return go.Figure()
-
-    fig = px.histogram(
-        df,
-        x=metric,
-        color="Strategy",
-        marginal="box",
-        opacity=0.7,
-        barmode="overlay",
-        title=f"📊 Distribution of {metric} Across Strategies"
-    )
-
-    fig.update_layout(
-        xaxis_title=metric,
-        yaxis_title="Count",
-        bargap=0.1,
-        height=500
-    )
-
-    return fig
-
-def histogram_viewer_ui(metric):
-    return generate_histogram(metric)