Update app.py

app.py

@@ -132,210 +132,39 @@ def equity_curve_plot(df, label="Equity Curve"):
     fig.update_layout(title=f"📈 {label}", xaxis_title="Week", yaxis_title="Balance ($)", height=400)
     return fig
 
-import os
-import gradio as gr
-import pandas as pd
-import numpy as np
-import plotly.graph_objs as go
-import plotly.express as px
-
-os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
-try:
-    gr.analytics_enabled = False
-except:
-    pass
-
-# === STRATEGY PRESETS ===
-def get_strategy_presets():
-    return {
-        "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,
-            "fatigue": 0.0, "trump_vol": 0.0,
-            "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,
-            "fatigue": 0.0, "trump_vol": 0.0,
-            "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,
-            "fatigue": 0.0, "trump_vol": 0.0,
-            "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,
-            "fatigue": 0.0, "trump_vol": 0.0,
-            "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,
-            "fatigue": 0.0, "trump_vol": 0.0,
-            "description": "Intraday consistency with a balanced reward profile."
-        }
-    }
-
-strategy_presets = get_strategy_presets()
-
-# === CORE SIMULATION ===
-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, fatigue=0.0, trump_vol=0.0):
-    if tp1_prob + tp2_prob >= 1.0:
-        return pd.DataFrame(), {"Error": "Invalid probability config. TP1 + TP2 must be < 1.0"}
-    
-    sl_prob = 1.0 - tp1_prob - tp2_prob
-    balance, peak, drawdown = starting_balance, starting_balance, 0
-    tp1_hits = tp2_hits = sl_hits = 0
-    max_win_streak = max_loss_streak = cur_win_streak = cur_loss_streak = 0
-    fatigue_multiplier = 1.0 - fatigue * 0.4
-    trump_vol_factor = np.random.normal(1.0, 0.2 * trump_vol)
-    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_amount = balance * base_risk_pct * np.random.uniform(0.9, 1.1)
-            risk_amount *= trump_vol_factor
-            if fatigue > 0.6 and cur_loss_streak >= 3 and np.random.rand() < fatigue * 0.25:
-                outcome = "SL"
-            else:
-                outcome = np.random.choice(["TP1", "TP2", "SL"], p=[tp1_prob, tp2_prob, sl_prob])
-
-            if outcome == "TP1":
-                balance += risk_amount * tp1_r * fatigue_multiplier
-                tp1_hits += 1
-                cur_win_streak += 1
-                cur_loss_streak = 0
-            elif outcome == "TP2":
-                balance += risk_amount * tp2_r * fatigue_multiplier
-                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)
-
-        log.append({
-            "Week": week, "Start Balance": round(week_start, 2),
-            "End Balance": round(balance, 2),
-            "Weekly Return (%)": round((balance - week_start) / week_start * 100, 2)
-        })
-
-    df = pd.DataFrame(log)
-    returns = df["End Balance"].pct_change().dropna()
-    sharpe = 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, 2),
-        "EdgeCast Score": round(score, 2)
-    }
-    return df, summary
-
-# === VISUALIZATION ===
-def equity_curve_plot(df, label="Equity Curve"):
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(x=df["Week"], y=df["End Balance"], mode="lines+markers", name=label))
-    fig.update_layout(title=f"📈 {label}", xaxis_title="Week", yaxis_title="Balance ($)", height=400)
-    return fig
-
-def generate_histogram(metric="EdgeCast Score", runs=100):
+# === LINE GRAPH ===
+def line_graph_viewer_ui(metric="Final Balance"):
+    # Generate data for the line graph based on the selected metric
     all_metrics = []
     for name, config in strategy_presets.items():
-        for _ in range(runs):
-            _, 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"], config["fatigue"], config["trump_vol"]
-            )
-            if metric in summary:
-                all_metrics.append({
-                    "Strategy": name,
-                    metric: summary[metric]
-                })
+        _, 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"], config["fatigue"], config["trump_vol"]
+        )
+        if metric in summary:
+            all_metrics.append({
+                "Strategy": name,
+                metric: summary[metric]
+            })
 
     df = pd.DataFrame(all_metrics)
 
-    fig = px.histogram(
+    # Generate a line graph of the selected metric
+    fig = px.line(
         df,
-        x=metric,
+        x="Strategy",
+        y=metric,
         color="Strategy",
-        marginal="box",
-        opacity=0.75,
-        barmode="overlay",
-        nbins=30,
-        title=f"📊 Distribution of {metric} Across Strategies"
+        title=f"📊 Line Graph of {metric}",
+        labels={metric: f"{metric}"}
     )
 
     fig.update_layout(
-        xaxis_title=metric,
-        yaxis_title="Count",
-        bargap=0.1,
+        xaxis_title="Strategy",
+        yaxis_title=metric,
         height=500
     )
-
-    return fig
-
-
-def histogram_viewer_ui(metric):
-    return generate_histogram(metric)
-
-# === ANALYSIS TOOLS ===
-def analytics_dashboard(rank_by="EdgeCast Score"):
-    results = []
-    for name, config in strategy_presets.items():
-        _, summary = simulate_tp_strategy_full(**{k: v for k, v in config.items() if k != "description"})
-        summary["Strategy"] = name
-        results.append(summary)
-    df = pd.DataFrame(results)
-    winner_vals = {
-        "Final Balance": df["Final Balance"].max(),
-        "Sharpe Ratio": df["Sharpe Ratio"].max(),
-        "EdgeCast Score": df["EdgeCast Score"].max(),
-        "Max Drawdown %": df["Max Drawdown %"].min()
-    }
-    df = df.sort_values(rank_by, ascending=(rank_by == "Max Drawdown %")).reset_index(drop=True)
-    df.insert(0, "🏅 Rank", [f"#{i+1}" for i in df.index])
-    for col in winner_vals:
-        df[col] = df[col].apply(lambda x: f"{round(x,2)} 🏆" if x == winner_vals[col] else f"{round(x,2)}")
-    return df[["🏅 Rank", "Strategy", "Final Balance", "Sharpe Ratio", "EdgeCast Score", "Max Drawdown %"]]
-
-def show_descriptions():
-    return pd.DataFrame([{"Strategy": name, "Description": cfg["description"]} for name, cfg in strategy_presets.items()])
-
-def generate_risk_matrix():
-    names = list(strategy_presets.keys())
-    scores = {n: simulate_tp_strategy_full(**{k: v for k, v in cfg.items() if k != "description"})[1]["EdgeCast Score"] for n, cfg in strategy_presets.items()}
-    matrix = np.array([[abs(scores[a] - scores[b]) for b in names] for a in names])
-    fig = px.imshow(matrix, x=names, y=names, text_auto=".2f", color_continuous_scale="RdYlGn_r", labels={"color": "Δ Score"})
-    fig.update_layout(title="🧠 Risk Matrix (Score Δ)", height=600)
     return fig
 
 # === STRATEGY RUNNERS ===
@@ -375,41 +204,6 @@ def dual_manual_battle(
     fig.update_layout(title="⚔️ Manual Strategy Battle", xaxis_title="Week", yaxis_title="Balance")
     return df_summary, fig
 
-def get_manual_battle_interface():
-    return gr.Interface(
-        fn=dual_manual_battle,
-        inputs=[
-            # A Config
-            gr.Slider(100, 20000, 2500, label="A: Start Balance"),
-            gr.Slider(1, 10, 3, label="A: Trades Min"),
-            gr.Slider(1, 15, 7, label="A: Trades Max"),
-            gr.Slider(1, 52, 12, label="A: Weeks"),
-            gr.Slider(0, 1, 0.3, step=0.05, label="A: TP1 %"),
-            gr.Slider(0, 1, 0.3, step=0.05, label="A: TP2 %"),
-            gr.Slider(0.1, 5.0, 1.0, step=0.1, label="A: TP1 R"),
-            gr.Slider(0.1, 20.0, 2.0, step=0.1, label="A: TP2 R"),
-            gr.Slider(0.001, 0.05, 0.01, step=0.001, label="A: Risk %"),
-            gr.Slider(0, 100000, 0, step=500, label="A: Profit Target"),
-            gr.Slider(0, 1, 0.0, step=0.1, label="A: Fatigue"),
-            gr.Slider(0, 1, 0.0, step=0.1, label="A: Trump Volatility"),
-            # B Config
-            gr.Slider(100, 20000, 2500, label="B: Start Balance"),
-            gr.Slider(1, 10, 3, label="B: Trades Min"),
-            gr.Slider(1, 15, 7, label="B: Trades Max"),
-            gr.Slider(1, 52, 12, label="B: Weeks"),
-            gr.Slider(0, 1, 0.3, step=0.05, label="B: TP1 %"),
-            gr.Slider(0, 1, 0.3, step=0.05, label="B: TP2 %"),
-            gr.Slider(0.1, 5.0, 1.0, step=0.1, label="B: TP1 R"),
-            gr.Slider(0.1, 20.0, 2.0, step=0.1, label="B: TP2 R"),
-            gr.Slider(0.001, 0.05, 0.01, step=0.001, label="B: Risk %"),
-            gr.Slider(0, 100000, 0, step=500, label="B: Profit Target"),
-            gr.Slider(0, 1, 0.0, step=0.1, label="B: Fatigue"),
-            gr.Slider(0, 1, 0.0, step=0.1, label="B: Trump Volatility")
-        ],
-        outputs=["dataframe", gr.Plot()],
-        title="🧪 Manual Strategy Battle"
-    )
-
 # === LAUNCH INTERFACE ===
 app = gr.TabbedInterface(
     interface_list=[
@@ -452,7 +246,7 @@ app = gr.TabbedInterface(
 
         # 📊 Line Graph Viewer Tab
         gr.Interface(
-            fn=histogram_viewer_ui,
+            fn=line_graph_viewer_ui,
             inputs=gr.Dropdown(
                 choices=["Final Balance", "Sharpe Ratio", "EdgeCast Score", "Max Drawdown %"],
                 label="Select Metric"