Update app.py

app.py

@@ -4,44 +4,47 @@ import pandas as pd
 import numpy as np
 import plotly.graph_objs as go
 
+# Disable analytics
 os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
-try: gr.analytics_enabled = False
-except: pass
-
-# 📘 STRATEGY PRESETS
+try:
+    gr.analytics_enabled = False
+except:
+    pass
+
+# ===========================
+# Strategy Presets w/ Descriptions
+# ===========================
 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": "Aggressive Prop Trader – High-frequency with elevated risk. Seeks large returns on more trades."
+        "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."
     },
     "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": "Conservative Swing Trader – Lower frequency & risk. Prioritizes stability and capital preservation."
+        "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."
     },
     "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": "Momentum Scalper – Fast-paced intraday with micro-trend capture. Moderate risk and trade count."
+        "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."
     },
     "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": "Swing Sniper – Patient setup sniper with high reward setups. Low frequency, higher R-multiple."
+        "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."
     },
     "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": "Intraday Prop Mode – Balanced risk & frequency. Good for consistent engagement without extremes."
+        "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."
     }
 }
 
+# ===========================
+# 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,23 +67,23 @@ def simulate_tp_strategy_full(starting_balance, trades_min, trades_max, weeks,
         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):
+        trades = np.random.randint(trades_min, trades_max + 1)
+        for _ in range(trades):
             risk_pct = get_scaled_risk_pct(balance, base_risk_pct)
-            risk_amount = balance * risk_pct
+            risk = 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
+                balance += risk * tp1_r
                 tp1_hits += 1
                 cur_win_streak += 1
                 cur_loss_streak = 0
             elif outcome == "TP2":
-                balance += risk_amount * tp2_r
+                balance += risk * tp2_r
                 tp2_hits += 1
                 cur_win_streak += 1
                 cur_loss_streak = 0
             else:
-                balance -= risk_amount
+                balance -= risk
                 sl_hits += 1
                 cur_loss_streak += 1
                 cur_win_streak = 0
@@ -88,119 +91,124 @@ 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)
+        })
 
     summary = {
         "Final Balance": round(balance, 2),
-        "TP1 Hits": tp1_hits, "TP2 Hits": tp2_hits, "SL Hits": sl_hits,
+        "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
+        "Max Win Streak": max_win_streak,
+        "Max Loss Streak": max_loss_streak
     }
-    return pd.DataFrame(log), summary
 
-def summary_to_plot(df, summary):
+    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='Equity'))
-    fig.update_layout(title='📈 Equity Curve', xaxis_title='Week', yaxis_title='Balance', height=400)
+    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
 
 def run_preset_strategy(style):
-    config = strategy_presets[style]
-    df, summary = simulate_tp_strategy_full(**{k: v for k, v in config.items() if k != "description"})
-    return df, summary_to_plot(df, summary), strategy_presets[style]["description"]
-
-def run_manual_strategy(starting_balance, trades_min, trades_max, weeks, tp1_prob, tp2_prob,
-                        tp1_r, tp2_r, base_risk_pct, profit_target):
-    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)
-    return df, summary_to_plot(df, summary)
-
-def battle_strategies(style1, style2):
-    config1 = strategy_presets[style1]
-    config2 = strategy_presets[style2]
-    df1, s1 = simulate_tp_strategy_full(**{k: v for k, v in config1.items() if k != "description"})
-    df2, s2 = simulate_tp_strategy_full(**{k: v for k, v in config2.items() if k != "description"})
-
-    def compute_score(df, summary):
+    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"]
+
+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()
-        sharpe = round((returns.mean() / returns.std()) * np.sqrt(52), 2) if returns.std() > 0 else 0
+        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 = summary["Final Balance"] / (1 + max_dd)
-        summary["Sharpe"] = sharpe
-        summary["EdgeCast Score"] = round(score, 2)
-        return summary, sharpe
-
-    s1, sharpe1 = compute_score(df1, s1)
-    s2, sharpe2 = compute_score(df2, s2)
-
-    winner = style1 if s1["EdgeCast Score"] > s2["EdgeCast Score"] else style2
-
-    df_compare = pd.DataFrame({
-        "Metric": list(s1.keys()) + ["🏆 Winner"],
-        style1: list(s1.values()) + ["✅" if winner == style1 else ""],
-        style2: list(s2.values()) + ["✅" if winner == style2 else ""]
-    })
-
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(x=df1["Week"], y=df1["End Balance"], name=f"{style1} (Sharpe: {sharpe1})"))
-    fig.add_trace(go.Scatter(x=df2["Week"], y=df2["End Balance"], name=f"{style2} (Sharpe: {sharpe2})"))
-    fig.update_layout(title="📊 Strategy Battle – Sharpe Comparison", xaxis_title="Week", yaxis_title="Balance")
-
-    return df_compare, fig
-
-def show_descriptions():
-    return pd.DataFrame({
-        "Strategy": list(strategy_presets.keys()),
-        "Description": [v["description"] for v in strategy_presets.values()]
-    })
+        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():
-    return pd.DataFrame({
-        "Strategy": list(strategy_presets.keys()),
-        "Risk %": [v["base_risk_pct"] for v in strategy_presets.values()],
-        "TP1 R": [v["tp1_r"] for v in strategy_presets.values()],
-        "TP2 R": [v["tp2_r"] for v in strategy_presets.values()],
-        "TP1 %": [v["tp1_prob"] for v in strategy_presets.values()],
-        "TP2 %": [v["tp2_prob"] for v in strategy_presets.values()],
-    })
-
-# 🧠 Gradio Interface Tabs
+    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(choices=list(strategy_presets.keys()), label="Select Strategy"),
-                          outputs=["dataframe", "plot", "text"],
-                          title="🎯 Preset Mode")
-
-manual_tab = gr.Interface(fn=run_manual_strategy,
-                          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, 1.2, step=0.1, label="TP1 R"),
-                              gr.Slider(0.1, 30, 2.4, 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", "plot"],
-                          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", "plot"],
-                          title="🥊 Strategy Battle")
-
-desc_tab = gr.Interface(fn=show_descriptions, inputs=[], outputs="dataframe", title="📘 Strategy Descriptions")
-matrix_tab = gr.Interface(fn=risk_matrix, inputs=[], outputs="dataframe", title="🧠 Risk Matrix Visualizer")
+    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"
+)
+
+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")
+    ],
+    outputs="dataframe",
+    title="🥊 Strategy Battle"
+)
+
+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, desc_tab, matrix_tab],
-    tab_names=["Preset", "Manual", "Battle", "Descriptions", "Risk Matrix"],
-    title="EdgeCast – Strategy Simulation Suite"
-).launch()
+    [preset_tab, manual_tab, battle_tab, analytics_tab, desc_tab, risk_tab],
+    tab_names=["Preset", "Manual", "Battle", "Analytics", "Descriptions", "Risk Matrix"]
+).launch()