Update app.py

app.py

@@ -7,8 +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 = {
@@ -53,161 +55,211 @@ def get_scaled_risk_pct(balance, base_risk_pct):
 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):
-    try:
-        sl_prob = 1.0 - tp1_prob - tp2_prob
-        balance = starting_balance
-        peak = balance
-        drawdown = 0
-        tp1_hits = tp2_hits = sl_hits = 0
-        max_win_streak = max_loss_streak = 0
-        cur_win_streak = cur_loss_streak = 0
-        log = []
-
-        for week in range(1, weeks + 1):
-            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 = get_scaled_risk_pct(balance, base_risk_pct)
-                risk_amount = balance * risk_pct
-                outcome = np.random.choice(["TP1", "TP2", "SL"], p=[tp1_prob, tp2_prob, sl_prob])
-                if outcome == "TP1":
-                    balance += risk_amount * tp1_r
-                    tp1_hits += 1
-                    cur_win_streak += 1
-                    cur_loss_streak = 0
-                elif outcome == "TP2":
-                    balance += risk_amount * tp2_r
-                    tp2_hits += 1
-                    cur_win_streak += 1
-                    cur_loss_streak = 0
-                else:
-                    balance -= risk_amount
-                    sl_hits += 1
-                    cur_loss_streak += 1
-                    cur_win_streak = 0
-                max_win_streak = max(max_win_streak, cur_win_streak)
-                max_loss_streak = max(max_loss_streak, cur_loss_streak)
-                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)
-            })
-
-        df = pd.DataFrame(log)
-        returns = df["End Balance"].pct_change().dropna()
-        volatility = returns.std() * np.sqrt(52)
-        sharpe = returns.mean() / volatility * np.sqrt(52) if volatility > 0 else 0
-        score = balance / (1 + drawdown)
-
-        summary = {
-            "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, 2),
-            "EdgeCast Score": round(score, 2)
-        }
-        return df, summary
-    except Exception as e:
-        return pd.DataFrame(), {"Error": str(e)}
+    sl_prob = 1.0 - tp1_prob - tp2_prob
+    balance = starting_balance
+    peak = balance
+    drawdown = 0
+    tp1_hits = tp2_hits = sl_hits = 0
+    max_win_streak = max_loss_streak = 0
+    cur_win_streak = cur_loss_streak = 0
+    log = []
 
+    for week in range(1, weeks + 1):
+        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 = get_scaled_risk_pct(balance, base_risk_pct)
+            risk_amount = balance * risk_pct
+            outcome = np.random.choice(["TP1", "TP2", "SL"], p=[tp1_prob, tp2_prob, sl_prob])
+            if outcome == "TP1":
+                balance += risk_amount * tp1_r
+                tp1_hits += 1
+                cur_win_streak += 1
+                cur_loss_streak = 0
+            elif outcome == "TP2":
+                balance += risk_amount * tp2_r
+                tp2_hits += 1
+                cur_win_streak += 1
+                cur_loss_streak = 0
+            else:
+                balance -= risk_amount
+                sl_hits += 1
+                cur_loss_streak += 1
+                cur_win_streak = 0
+            max_win_streak = max(max_win_streak, cur_win_streak)
+            max_loss_streak = max(max_loss_streak, cur_loss_streak)
+            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)})
+
+    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
+    score = balance / (1 + drawdown)
+
+    summary = {
+        "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)
+    }
+    return df, summary
+# Run preset from dropdown
 def run_preset_strategy(style):
     config = strategy_presets[style]
-    df, summary = simulate_tp_strategy_full(**{k: config[k] for k in config if k not in ["description"]})
+    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"]
+    )
     return df, summary, config["description"]
 
+# Battle mode comparison
 def battle_strategies(style1, style2):
     df1, s1 = simulate_tp_strategy_full(**strategy_presets[style1])
     df2, s2 = simulate_tp_strategy_full(**strategy_presets[style2])
     s1["Strategy"] = style1
     s2["Strategy"] = style2
     df_compare = pd.DataFrame([s1, s2])
-    winner = df_compare.loc[df_compare["EdgeCast Score"].idxmax(), "Strategy"]
+    df_compare = df_compare[["Strategy"] + [col for col in s1 if col != "Strategy"]]
+
+    # Determine winners
+    edgecast_winner = df_compare.loc[df_compare["EdgeCast Score"].idxmax(), "Strategy"]
+    sharpe_winner = df_compare.loc[df_compare["Sharpe Ratio"].idxmax(), "Strategy"]
+    pnl_winner = df_compare.loc[df_compare["Final Balance"].idxmax(), "Strategy"]
 
+    # Bold + highlight the winners
+    def highlight(row):
+        style = []
+        if row["Strategy"] == edgecast_winner: style.append("background-color: #d4edda; font-weight: bold")
+        else: style.append("")
+        return style * len(row)
+
+    # Chart
     fig = go.Figure()
-    fig.add_trace(go.Scatter(x=df1["Week"], y=df1["End Balance"], name=f"{style1} (Sharpe: {s1['Sharpe Ratio']})"))
-    fig.add_trace(go.Scatter(x=df2["Week"], y=df2["End Balance"], name=f"{style2} (Sharpe: {s2['Sharpe Ratio']})"))
-    fig.update_layout(title=f"Strategy Battle – Sharpe Comparison", xaxis_title="Week", yaxis_title="Balance")
+    fig.add_trace(go.Scatter(x=df1["Week"], y=df1["End Balance"], name=f"{style1}"))
+    fig.add_trace(go.Scatter(x=df2["Week"], y=df2["End Balance"], name=f"{style2}"))
+    fig.update_layout(title=f"📊 Battle – 🏆 {edgecast_winner} (Best EdgeCast Score)",
+                      xaxis_title="Week", yaxis_title="Balance")
 
-    df_compare["🏆 Winner"] = df_compare["Strategy"] == winner
-    return df_compare, fig
+    return df_compare.style.apply(highlight, axis=1), fig
 
+# Analytics leaderboard
 def analytics_dashboard():
     rows = []
     for name, config in strategy_presets.items():
         _, s = simulate_tp_strategy_full(**config)
         s["Strategy"] = name
         rows.append(s)
-    return pd.DataFrame(rows).sort_values("EdgeCast Score", ascending=False).reset_index(drop=True)
+    df = pd.DataFrame(rows)
+    return df.sort_values("EdgeCast Score", ascending=False).reset_index(drop=True)
 
+# Show strategy descriptions
 def show_descriptions():
-    return pd.DataFrame([
-        {"Strategy": k, "Description": v["description"]}
-        for k, v in strategy_presets.items()
-    ])
-
+    descs = [{"Strategy": k, "Description": v["description"]} for k, v in strategy_presets.items()]
+    return pd.DataFrame(descs)
+# Risk Matrix Heatmap tab
 def generate_risk_matrix():
-    strategies = list(strategy_presets.keys())
+    strat_names = list(strategy_presets.keys())
     scores = {}
-    for strat in strategies:
-        _, s = simulate_tp_strategy_full(**strategy_presets[strat])
-        scores[strat] = s["EdgeCast Score"]
-    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, color_continuous_scale="RdYlGn_r",
-                    text_auto=".2f", labels=dict(color="Δ Score"))
-    fig.update_traces(hovertemplate="Δ = %{z:.2f} between %{x} and %{y}")
-    fig.update_layout(title="🧠 Risk Matrix (Δ Score Heatmap)", height=500)
+    for name in strat_names:
+        _, s = simulate_tp_strategy_full(**strategy_presets[name])
+        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>")
     return fig
 
-# 🚀 Launch App
-gr.TabbedInterface(
+# Build the app
+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"],
-                     title="🎯 Preset Mode"),
-
-        gr.Interface(fn=simulate_tp_strategy_full,
-                     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, 20.0, 1.0, step=0.1, label="TP1 R (Risk:Reward)"),
-                         gr.Slider(0.1, 20.0, 2.0, step=0.1, label="TP2 R (Risk:Reward)"),
-                         gr.Slider(0.001, 0.05, 0.01, step=0.001, label="Risk %"),
-                         gr.Slider(0, 100000, 0, step=500, label="Profit Target 💰")
-                     ],
-                     outputs=["dataframe", "json"],
-                     title="🛠️ Manual Config"),
-
-        gr.Interface(fn=battle_strategies,
-                     inputs=[
-                         gr.Dropdown(choices=list(strategy_presets.keys()), label="Strategy 1"),
-                         gr.Dropdown(choices=list(strategy_presets.keys()), label="Strategy 2")
-                     ],
-                     outputs=["dataframe", gr.Plot()],
-                     title="🥊 Battle Mode"),
-
-        gr.Interface(fn=analytics_dashboard, inputs=[], outputs="dataframe", title="📊 Analytics"),
-
-        gr.Interface(fn=show_descriptions, inputs=[], outputs="dataframe", title="📘 Descriptions"),
-
-        gr.Interface(fn=generate_risk_matrix, inputs=[], outputs=gr.Plot(), title="🔬 Risk Matrix")
+
+        # Preset Tab
+        gr.Interface(
+            fn=run_preset_strategy,
+            inputs=gr.Dropdown(choices=list(strategy_presets.keys()), label="Select Strategy"),
+            outputs=["dataframe", "json", "text"],
+            title="🎯 Preset Mode"
+        ),
+
+        # Manual Tab with 20:1 RR
+        gr.Interface(
+            fn=simulate_tp_strategy_full,
+            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, 20.0, 1.0, step=0.1, label="TP1 R"),
+                gr.Slider(0.1, 40.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 💰")
+            ],
+            outputs=["dataframe", "json"],
+            title="🛠️ Manual Config"
+        ),
+
+        # Battle Tab
+        gr.Interface(
+            fn=battle_strategies,
+            inputs=[
+                gr.Dropdown(choices=list(strategy_presets.keys()), label="Strategy 1"),
+                gr.Dropdown(choices=list(strategy_presets.keys()), label="Strategy 2")
+            ],
+            outputs=["dataframe", gr.Plot()],
+            title="🥊 Battle Mode"
+        ),
+
+        # Analytics Leaderboard Tab
+        gr.Interface(
+            fn=analytics_dashboard,
+            inputs=[],
+            outputs="dataframe",
+            title="📊 Analytics Leaderboard"
+        ),
+
+        # Strategy Descriptions Tab
+        gr.Interface(
+            fn=show_descriptions,
+            inputs=[],
+            outputs="dataframe",
+            title="📘 Strategy Descriptions"
+        ),
+
+        # Risk Matrix Tab
+        gr.Interface(
+            fn=generate_risk_matrix,
+            inputs=[],
+            outputs=gr.Plot(),
+            title="🔬 Risk Matrix"
+        )
     ],
     tab_names=["Preset", "Manual", "Battle", "Analytics", "Descriptions", "Risk Matrix"],
     title="EdgeCast – Strategy Simulation Suite"
-).launch()
+)
+
+# 🚀 Launch the app
+app.launch()