Update app.py

app.py

@@ -3,48 +3,49 @@ import gradio as gr
 import pandas as pd
 import numpy as np
 import plotly.graph_objs as go
+import plotly.express as px
 
-# Disable analytics
+# Disable Gradio analytics
 os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
 try:
     gr.analytics_enabled = False
 except:
     pass
 
-# ===========================
-# Strategy Presets w/ Descriptions
-# ===========================
+# Strategy Presets
 strategy_presets = {
     "Aggressive Prop Trader": {
         "starting_balance": 2500, "trades_min": 5, "trades_max": 10, "weeks": 12,
-        "tp1_prob": 0.25, "tp2_prob": 0.4, "tp1_r": 1.2, "tp2_r": 2.4, "base_risk_pct": 0.015, "profit_target": None,
-        "description": "High-frequency strategy with elevated risk and reward. Suitable for advanced traders."
+        "tp1_prob": 0.25, "tp2_prob": 0.4, "tp1_r": 1.2, "tp2_r": 2.4,
+        "base_risk_pct": 0.015, "profit_target": None,
+        "description": "High-frequency, high-risk with strong upside potential."
     },
     "Conservative Swing Trader": {
         "starting_balance": 2500, "trades_min": 2, "trades_max": 5, "weeks": 12,
-        "tp1_prob": 0.35, "tp2_prob": 0.25, "tp1_r": 0.9, "tp2_r": 1.8, "base_risk_pct": 0.01, "profit_target": None,
-        "description": "Steady long-term strategy with lower risk per trade. Capital preservation focused."
+        "tp1_prob": 0.35, "tp2_prob": 0.25, "tp1_r": 0.9, "tp2_r": 1.8,
+        "base_risk_pct": 0.01, "profit_target": None,
+        "description": "Lower frequency, prioritizes preservation and steady returns."
     },
     "Momentum Scalper": {
         "starting_balance": 2500, "trades_min": 4, "trades_max": 8, "weeks": 12,
-        "tp1_prob": 0.3, "tp2_prob": 0.35, "tp1_r": 1.0, "tp2_r": 2.2, "base_risk_pct": 0.012, "profit_target": None,
-        "description": "Short-term strategy targeting quick price bursts. Balanced risk-to-reward."
+        "tp1_prob": 0.3, "tp2_prob": 0.35, "tp1_r": 1.0, "tp2_r": 2.2,
+        "base_risk_pct": 0.012, "profit_target": None,
+        "description": "Intraday momentum strategy for fast-paced trading windows."
     },
     "Swing Sniper": {
         "starting_balance": 2500, "trades_min": 2, "trades_max": 4, "weeks": 12,
-        "tp1_prob": 0.2, "tp2_prob": 0.5, "tp1_r": 1.1, "tp2_r": 3.0, "base_risk_pct": 0.008, "profit_target": None,
-        "description": "Precision-based entries with high reward targets. Lower frequency, high efficiency."
+        "tp1_prob": 0.2, "tp2_prob": 0.5, "tp1_r": 1.1, "tp2_r": 3.0,
+        "base_risk_pct": 0.008, "profit_target": None,
+        "description": "Selective entries with high RR setups. Less frequent."
     },
     "Intraday Prop Mode": {
         "starting_balance": 2500, "trades_min": 3, "trades_max": 7, "weeks": 12,
-        "tp1_prob": 0.3, "tp2_prob": 0.3, "tp1_r": 1.0, "tp2_r": 2.0, "base_risk_pct": 0.02, "profit_target": None,
-        "description": "Balanced intraday strategy used in prop firms. Prioritizes steady growth."
+        "tp1_prob": 0.3, "tp2_prob": 0.3, "tp1_r": 1.0, "tp2_r": 2.0,
+        "base_risk_pct": 0.02, "profit_target": None,
+        "description": "Intraday consistency with a balanced reward profile."
     }
 }
 
-# ===========================
-# Core Simulation Function
-# ===========================
 def get_scaled_risk_pct(balance, base_risk_pct):
     if balance < 5000: return base_risk_pct
     elif balance < 10000: return base_risk_pct * 0.75
@@ -64,26 +65,25 @@ def simulate_tp_strategy_full(starting_balance, trades_min, trades_max, weeks,
     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
-        trades = np.random.randint(trades_min, trades_max + 1)
-        for _ in range(trades):
+        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 = balance * 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 * tp1_r
+                balance += risk_amount * tp1_r
                 tp1_hits += 1
                 cur_win_streak += 1
                 cur_loss_streak = 0
             elif outcome == "TP2":
-                balance += risk * tp2_r
+                balance += risk_amount * tp2_r
                 tp2_hits += 1
                 cur_win_streak += 1
                 cur_loss_streak = 0
             else:
-                balance -= risk
+                balance -= risk_amount
                 sl_hits += 1
                 cur_loss_streak += 1
                 cur_win_streak = 0
@@ -91,13 +91,15 @@ def simulate_tp_strategy_full(starting_balance, trades_min, trades_max, weeks,
             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)
-        })
+        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),
@@ -106,109 +108,114 @@ def simulate_tp_strategy_full(starting_balance, trades_min, trades_max, weeks,
         "SL Hits": sl_hits,
         "Max Drawdown %": round(drawdown, 2),
         "Max Win Streak": max_win_streak,
-        "Max Loss Streak": max_loss_streak
+        "Max Loss Streak": max_loss_streak,
+        "Sharpe Ratio": round(sharpe_ratio, 2),
+        "EdgeCast Score": round(score, 2)
     }
-
-    df = pd.DataFrame(log)
     return df, summary
 
-# ===========================
-# Helpers
-# ===========================
-def equity_plot(df):
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(x=df["Week"], y=df["End Balance"],
-                             mode="lines+markers", name="Balance"))
-    fig.update_layout(title="Equity Curve", xaxis_title="Week", yaxis_title="Balance")
-    return fig
-
+# 🔘 TAB: Preset Strategy
 def run_preset_strategy(style):
-    cfg = strategy_presets[style]
-    df, summary = simulate_tp_strategy_full(**{k: v for k, v in cfg.items() if k != "description"})
-    return df, equity_plot(df), cfg["description"]
+    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"]
+
+# 🔘 TAB: Battle
+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])
+    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
+
+# 🔘 TAB: Analytics Leaderboard
 def analytics_dashboard():
-    results = []
-    for name, cfg in strategy_presets.items():
-        df, s = simulate_tp_strategy_full(**{k: v for k, v in cfg.items() if k != "description"})
-        returns = df["End Balance"].pct_change().dropna()
-        volatility = returns.std() * np.sqrt(52)
-        sharpe = returns.mean() / returns.std() * np.sqrt(52) if returns.std() else 0
-        peak = df["End Balance"].cummax()
-        dd = (peak - df["End Balance"]) / peak
-        max_dd = dd.max() * 100 if not dd.empty else 0
-        score = df["End Balance"].iloc[-1] / (1 + max_dd)
-        results.append({
-            "Strategy": name,
-            "Final Balance": round(df["End Balance"].iloc[-1], 2),
-            "Sharpe": round(sharpe, 2),
-            "Max Drawdown %": round(max_dd, 2),
-            "EdgeCast Score": round(score, 2)
-        })
-    df_all = pd.DataFrame(results).sort_values("EdgeCast Score", ascending=False).reset_index(drop=True)
-    return df_all.style.apply(lambda x: ['background-color: #d4edda' if v == x.max() and x.name == 'Sharpe' else '' for v in x], axis=0)
-
-def strategy_descriptions():
-    rows = [{"Strategy": k, "Description": v["description"]} for k, v in strategy_presets.items()]
-    return pd.DataFrame(rows)
-
-def risk_matrix():
     rows = []
-    for k, v in strategy_presets.items():
-        rows.append({
-            "Strategy": k,
-            "Risk %": v["base_risk_pct"],
-            "TP1 R": v["tp1_r"],
-            "TP2 R": v["tp2_r"],
-            "TP1 %": v["tp1_prob"],
-            "TP2 %": v["tp2_prob"]
-        })
-    return pd.DataFrame(rows)
-
-# ===========================
-# UI Setup
-# ===========================
-preset_tab = gr.Interface(fn=run_preset_strategy,
-    inputs=gr.Dropdown(list(strategy_presets.keys()), label="Select Strategy"),
-    outputs=["dataframe", gr.Plot(), gr.Text()],
-    title="🎯 Preset Mode"
-)
-
-manual_tab = 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, 5, 1.0, step=0.1, label="TP1 R"),
-        gr.Slider(0.1, 10, 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"
-)
+    for name, config in strategy_presets.items():
+        _, s = simulate_tp_strategy_full(**config)
+        s["Strategy"] = name
+        rows.append(s)
+    df = pd.DataFrame(rows)
+    return df.sort_values("EdgeCast Score", ascending=False).reset_index(drop=True)
+
+# 🔘 TAB: Descriptions
+def show_descriptions():
+    descs = [{"Strategy": k, "Description": v["description"]} for k, v in strategy_presets.items()]
+    return pd.DataFrame(descs)
+
+# 🔘 TAB: 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])
+        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
 
-battle_tab = gr.Interface(
-    fn=lambda a, b: simulate_tp_strategy_full(**{k: v for k, v in strategy_presets[a].items() if k != "description"})[0].merge(
-        simulate_tp_strategy_full(**{k: v for k, v in strategy_presets[b].items() if k != "description"})[0],
-        on="Week", suffixes=(f" ({a})", f" ({b})")
-    ),
-    inputs=[
-        gr.Dropdown(list(strategy_presets.keys()), label="Strategy 1"),
-        gr.Dropdown(list(strategy_presets.keys()), label="Strategy 2")
+# ✅ Gradio App Tabs
+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, 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 💰")
+                     ],
+                     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 Leaderboard"),
+
+        gr.Interface(fn=show_descriptions,
+                     inputs=[], outputs="dataframe",
+                     title="📘 Strategy Descriptions"),
+
+        gr.Interface(fn=generate_risk_matrix,
+                     inputs=[], outputs=gr.Plot(),
+                     title="🔬 Risk Matrix")
     ],
-    outputs="dataframe",
-    title="🥊 Strategy Battle"
+    tab_names=["Preset", "Manual", "Battle", "Analytics", "Descriptions", "Risk Matrix"],
+    title="EdgeCast – Strategy Simulation Suite"
 )
 
-analytics_tab = gr.Interface(fn=analytics_dashboard, inputs=[], outputs="dataframe", title="📊 Analytics")
-desc_tab = gr.Interface(fn=strategy_descriptions, inputs=[], outputs="dataframe", title="📘 Descriptions")
-risk_tab = gr.Interface(fn=risk_matrix, inputs=[], outputs="dataframe", title="🧠 Risk Matrix Visualizer")
-
-gr.TabbedInterface(
-    [preset_tab, manual_tab, battle_tab, analytics_tab, desc_tab, risk_tab],
-    tab_names=["Preset", "Manual", "Battle", "Analytics", "Descriptions", "Risk Matrix"]
-).launch()
+app.launch()