Update app.py

app.py

@@ -7,12 +7,10 @@ import plotly.express as px
 
 # Disable Gradio analytics
 os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
-try:
-    gr.analytics_enabled = False
-except:
-    pass
+try: gr.analytics_enabled = False
+except: pass
 
-# Strategy Presets
+# 📌 Strategy Presets
 strategy_presets = {
     "Aggressive Prop Trader": {
         "starting_balance": 2500, "trades_min": 5, "trades_max": 10, "weeks": 12,
@@ -92,8 +90,10 @@ 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)})
+        log.append({
+            "Week": week, "Start Balance": round(week_start, 2),
+            "End Balance": round(balance, 2), "Weekly Return (%)": round(weekly_return, 2)
+        })
 
     df = pd.DataFrame(log)
     returns = df["End Balance"].pct_change().dropna()
@@ -102,80 +102,82 @@ def simulate_tp_strategy_full(starting_balance, trades_min, trades_max, weeks,
     score = balance / (1 + drawdown)
 
     summary = {
-        "Final Balance": round(balance, 2),
-        "TP1 Hits": tp1_hits,
-        "TP2 Hits": tp2_hits,
-        "SL Hits": sl_hits,
+        "Final Balance": round(balance, 2), "TP1 Hits": tp1_hits,
+        "TP2 Hits": tp2_hits, "SL Hits": sl_hits,
         "Max Drawdown %": round(drawdown, 2),
-        "Max Win Streak": max_win_streak,
-        "Max Loss Streak": max_loss_streak,
-        "Sharpe Ratio": round(sharpe_ratio, 2),
-        "EdgeCast Score": round(score, 2)
+        "Max Win Streak": max_win_streak, "Max Loss Streak": max_loss_streak,
+        "Sharpe": round(sharpe_ratio, 2), "EdgeCast Score": round(score, 2)
     }
+
     return df, summary
 
-# 🔘 TAB: Preset Strategy
+# 🔹 Preset Tab
 def run_preset_strategy(style):
     config = strategy_presets[style]
-    df, summary = simulate_tp_strategy_full(**{k: config[k] for k in config if k != "description"})
-    return df, summary, config["description"]
+    config_copy = {k: config[k] for k in config if k not in ["description"]}
+    df, summary = simulate_tp_strategy_full(**config_copy)
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=df["Week"], y=df["End Balance"], mode='lines+markers', name='Equity Curve'))
+    fig.update_layout(title='📈 Equity Curve', xaxis_title='Week', yaxis_title='Balance', height=400)
+    return df, summary, fig, config["description"]
 
-# 🔘 TAB: Battle
+# 🔹 Battle Tab
 def battle_strategies(style1, style2):
-    df1, s1 = simulate_tp_strategy_full(**strategy_presets[style1])
-    df2, s2 = simulate_tp_strategy_full(**strategy_presets[style2])
+    df1, s1 = simulate_tp_strategy_full(**{k: v for k, v in strategy_presets[style1].items() if k != "description"})
+    df2, s2 = simulate_tp_strategy_full(**{k: v for k, v in strategy_presets[style2].items() if k != "description"})
     s1["Strategy"] = style1
     s2["Strategy"] = style2
     df_compare = pd.DataFrame([s1, s2])
-    df_compare = df_compare[["Strategy"] + [col for col in s1 if col != "Strategy"]]
-
     winner = df_compare.loc[df_compare["EdgeCast Score"].idxmax(), "Strategy"]
 
     fig = go.Figure()
-    fig.add_trace(go.Scatter(x=df1["Week"], y=df1["End Balance"], name=style1))
-    fig.add_trace(go.Scatter(x=df2["Week"], y=df2["End Balance"], name=style2))
-    fig.update_layout(title=f"📊 Battle Mode – Winner: {winner} 🥇", xaxis_title="Week", yaxis_title="Balance")
-    return df_compare.style.apply(lambda row: ['font-weight: bold; background-color: #d4edda' if row.Strategy == winner else '' for _ in row], axis=1), fig
+    fig.add_trace(go.Scatter(x=df1["Week"], y=df1["End Balance"], name=f"{style1} (Sharpe: {s1['Sharpe']})"))
+    fig.add_trace(go.Scatter(x=df2["Week"], y=df2["End Balance"], name=f"{style2} (Sharpe: {s2['Sharpe']})"))
+    fig.update_layout(title=f"📊 Strategy Battle – Sharpe Comparison", xaxis_title="Week", yaxis_title="Balance")
 
-# 🔘 TAB: Analytics Leaderboard
+    df_compare["🏆 Winner"] = df_compare["Strategy"] == winner
+    return df_compare.style.apply(lambda r: ['background-color: #d4edda; font-weight: bold' if r["🏆 Winner"] else '' for _ in r], axis=1), fig
+
+# 🔹 Analytics
 def analytics_dashboard():
-    rows = []
+    results = []
     for name, config in strategy_presets.items():
-        _, s = simulate_tp_strategy_full(**config)
+        _, s = simulate_tp_strategy_full(**{k: config[k] for k in config if k != "description"})
         s["Strategy"] = name
-        rows.append(s)
-    df = pd.DataFrame(rows)
-    return df.sort_values("EdgeCast Score", ascending=False).reset_index(drop=True)
+        results.append(s)
+    return pd.DataFrame(results).sort_values("EdgeCast Score", ascending=False)
 
-# 🔘 TAB: Descriptions
+# 🔹 Descriptions
 def show_descriptions():
-    descs = [{"Strategy": k, "Description": v["description"]} for k, v in strategy_presets.items()]
-    return pd.DataFrame(descs)
+    return pd.DataFrame([
+        {"Strategy": name, "Description": config["description"]}
+        for name, config in strategy_presets.items()
+    ])
 
-# 🔘 TAB: Risk Matrix Heatmap
+# 🔹 Risk Matrix Heatmap
 def generate_risk_matrix():
-    strat_names = list(strategy_presets.keys())
     scores = {}
-    for name in strat_names:
-        _, s = simulate_tp_strategy_full(**strategy_presets[name])
+    for name in strategy_presets:
+        _, s = simulate_tp_strategy_full(**{k: v for k, v in strategy_presets[name].items() if k != "description"})
         scores[name] = s["EdgeCast Score"]
-    heatmap_data = np.zeros((len(strat_names), len(strat_names)))
-    for i, a in enumerate(strat_names):
-        for j, b in enumerate(strat_names):
-            heatmap_data[i, j] = abs(scores[a] - scores[b])
-    fig = px.imshow(heatmap_data,
-                    x=strat_names, y=strat_names, color_continuous_scale="RdYlGn_r",
-                    labels=dict(color="Score Δ"),
-                    title="🧠 Risk Matrix (Strategy Divergence)")
-    fig.update_traces(hovertemplate="From %{y} → %{x}: Δ=%{z}<extra></extra>")
+
+    strategies = list(scores.keys())
+    matrix = np.zeros((len(strategies), len(strategies)))
+    for i, a in enumerate(strategies):
+        for j, b in enumerate(strategies):
+            matrix[i, j] = abs(scores[a] - scores[b])
+
+    fig = px.imshow(matrix, x=strategies, y=strategies, text_auto=True,
+                    color_continuous_scale="RdYlGn_r", title="🔬 Risk Matrix (Δ Score Heatmap)")
+    fig.update_traces(hovertemplate="Δ Score: %{z}<extra></extra>")
     return fig
 
-# ✅ Gradio App Tabs
+# 🔧 Gradio Interface
 app = gr.TabbedInterface(
     interface_list=[
         gr.Interface(fn=run_preset_strategy,
                      inputs=gr.Dropdown(choices=list(strategy_presets.keys()), label="Select Strategy"),
-                     outputs=["dataframe", "json", "text"],
+                     outputs=["dataframe", "json", gr.Plot(), "text"],
                      title="🎯 Preset Mode"),
 
         gr.Interface(fn=simulate_tp_strategy_full,
@@ -186,10 +188,10 @@ app = gr.TabbedInterface(
                          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, 10.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, 5.0, 1.2, step=0.1, label="TP1 R"),
+                         gr.Slider(0.1, 5.0, 2.4, step=0.1, label="TP2 R"),
+                         gr.Slider(0.001, 0.05, 0.015, step=0.001, label="Risk %"),
+                         gr.Slider(0, 100000, 0, step=500, label="Profit Target")
                      ],
                      outputs=["dataframe", "json"],
                      title="🛠️ Manual Config"),
@@ -203,16 +205,13 @@ app = gr.TabbedInterface(
                      title="🥊 Battle Mode"),
 
         gr.Interface(fn=analytics_dashboard,
-                     inputs=[], outputs="dataframe",
-                     title="📊 Analytics Leaderboard"),
+                     inputs=[], outputs="dataframe", title="📊 Analytics"),
 
         gr.Interface(fn=show_descriptions,
-                     inputs=[], outputs="dataframe",
-                     title="📘 Strategy Descriptions"),
+                     inputs=[], outputs="dataframe", title="📘 Descriptions"),
 
         gr.Interface(fn=generate_risk_matrix,
-                     inputs=[], outputs=gr.Plot(),
-                     title="🔬 Risk Matrix")
+                     inputs=[], outputs=gr.Plot(), title="🧠 Risk Matrix")
     ],
     tab_names=["Preset", "Manual", "Battle", "Analytics", "Descriptions", "Risk Matrix"],
     title="EdgeCast – Strategy Simulation Suite"