Update app.py

app.py

@@ -10,7 +10,7 @@ os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
 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,
@@ -53,131 +53,129 @@ 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):
-    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": round(sharpe_ratio, 2), "EdgeCast Score": round(score, 2)
-    }
-
-    return df, summary
+    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)}
 
-# 🔹 Preset Tab
 def run_preset_strategy(style):
     config = strategy_presets[style]
-    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"]
+    df, summary = simulate_tp_strategy_full(**{k: config[k] for k in config if k not in ["description"]})
+    return df, summary, config["description"]
 
-# 🔹 Battle Tab
 def battle_strategies(style1, 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"})
+    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"]
 
     fig = go.Figure()
-    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")
+    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")
 
     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
+    return df_compare, fig
 
-# 🔹 Analytics
 def analytics_dashboard():
-    results = []
+    rows = []
     for name, config in strategy_presets.items():
-        _, s = simulate_tp_strategy_full(**{k: config[k] for k in config if k != "description"})
+        _, s = simulate_tp_strategy_full(**config)
         s["Strategy"] = name
-        results.append(s)
-    return pd.DataFrame(results).sort_values("EdgeCast Score", ascending=False)
+        rows.append(s)
+    return pd.DataFrame(rows).sort_values("EdgeCast Score", ascending=False).reset_index(drop=True)
 
-# 🔹 Descriptions
 def show_descriptions():
     return pd.DataFrame([
-        {"Strategy": name, "Description": config["description"]}
-        for name, config in strategy_presets.items()
+        {"Strategy": k, "Description": v["description"]}
+        for k, v in strategy_presets.items()
     ])
 
-# 🔹 Risk Matrix Heatmap
 def generate_risk_matrix():
+    strategies = list(strategy_presets.keys())
     scores = {}
-    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"]
-
-    strategies = list(scores.keys())
+    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, text_auto=True,
-                    color_continuous_scale="RdYlGn_r", title="🔬 Risk Matrix (Δ Score Heatmap)")
-    fig.update_traces(hovertemplate="Δ Score: %{z}<extra></extra>")
+    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)
     return fig
 
-# 🔧 Gradio Interface
-app = gr.TabbedInterface(
+# 🚀 Launch 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", gr.Plot(), "text"],
+                     outputs=["dataframe", "json", "text"],
                      title="🎯 Preset Mode"),
 
         gr.Interface(fn=simulate_tp_strategy_full,
@@ -188,10 +186,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.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")
+                         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"),
@@ -204,17 +202,12 @@ app = gr.TabbedInterface(
                      outputs=["dataframe", gr.Plot()],
                      title="🥊 Battle Mode"),
 
-        gr.Interface(fn=analytics_dashboard,
-                     inputs=[], outputs="dataframe", title="📊 Analytics"),
+        gr.Interface(fn=analytics_dashboard, inputs=[], outputs="dataframe", title="📊 Analytics"),
 
-        gr.Interface(fn=show_descriptions,
-                     inputs=[], outputs="dataframe", title="📘 Descriptions"),
+        gr.Interface(fn=show_descriptions, inputs=[], outputs="dataframe", title="📘 Descriptions"),
 
-        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", "Analytics", "Descriptions", "Risk Matrix"],
     title="EdgeCast – Strategy Simulation Suite"
-)
-
-app.launch()
+).launch()