Update app.py

app.py

@@ -1,64 +1,240 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+
+# 📌 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
+    },
+    "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
+    },
+    "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
+    },
+    "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
+    },
+    "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
+    }
+}
+
+# 🔁 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
+    elif balance < 20000: return base_risk_pct * 0.5
+    else: return base_risk_pct * 0.25
+
+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)
+        })
+
+    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
+    }
+
+    return pd.DataFrame(log), summary
+
+# 🧪 Manual Strategy Interface
+def run_manual_simulation(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)
+    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
+    peak = df['End Balance'].cummax()
+    dd = (peak - df['End Balance']) / peak
+    max_dd = dd.max() * 100 if not dd.empty else 0
+    final_balance = df['End Balance'].iloc[-1] if not df.empty else starting_balance
+    score = final_balance / (1 + max_dd)
+
+    summary.update({
+        "Volatility % (Annual)": round(volatility * 100, 2),
+        "Sharpe Ratio": round(sharpe_ratio, 2),
+        "EdgeCast Score": round(score, 2)
+    })
+
+    return df, summary
+
+# ⚔️ Battle Mode
+def battle_strategies(style1, style2):
+    p1 = strategy_presets[style1]
+    p2 = strategy_presets[style2]
+    df1, s1 = simulate_tp_strategy_full(**p1)
+    df2, s2 = simulate_tp_strategy_full(**p2)
+
+    def enrich_summary(df, summary):
+        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
+        peak_balance = df['End Balance'].cummax()
+        drawdowns = (peak_balance - df['End Balance']) / peak_balance
+        max_drawdown = drawdowns.max() * 100 if not drawdowns.empty else 0
+        final_balance = df['End Balance'].iloc[-1] if not df.empty else df['End Balance'].iloc[0]
+        edgecast_score = final_balance / (1 + max_drawdown)
+        summary["Volatility (Annualized)"] = round(volatility * 100, 2)
+        summary["Sharpe Ratio"] = round(sharpe_ratio, 2)
+        summary["Max Drawdown %"] = round(max_drawdown, 2)
+        summary["EdgeCast Score"] = round(edgecast_score, 2)
+        return summary
+
+    s1 = enrich_summary(df1, s1)
+    s2 = enrich_summary(df2, s2)
+
+    def badge(score):
+        if score >= 30000: return "💎 Elite"
+        elif score >= 20000: return "🥇 Pro"
+        elif score >= 10000: return "📈 Growing"
+        else: return "🟡 Developing"
+
+    badge1 = badge(s1["EdgeCast Score"])
+    badge2 = badge(s2["EdgeCast Score"])
+
+    plt.figure(figsize=(9, 5))
+    plt.plot(df1['Week'], df1['End Balance'], label=f"{style1} ({badge1})", marker='o')
+    plt.plot(df2['Week'], df2['End Balance'], label=f"{style2} ({badge2})", marker='o')
+    plt.title(f"🥊 Strategy Battle – {style1} vs {style2}")
+    plt.xlabel("Week")
+    plt.ylabel("Account Balance")
+    plt.grid(True)
+    plt.legend()
+    plt.tight_layout()
+    plot_path = "/tmp/battle_chart.png"
+    plt.savefig(plot_path)
+    plt.close()
+
+    df_compare = pd.DataFrame({
+        "Metric": list(s1.keys()) + ["Badge"],
+        style1: list(s1.values()) + [badge1],
+        style2: list(s2.values()) + [badge2]
+    })
+
+    return df_compare, plot_path
+
+# 📊 Leaderboard Tab
+def analytics_dashboard():
+    leaderboard = []
+    for name, config in strategy_presets.items():
+        df, summary = simulate_tp_strategy_full(**config)
+        returns = df['End Balance'].pct_change().dropna()
+        volatility = returns.std() * np.sqrt(52)
+        sharpe = returns.mean() / returns.std() * np.sqrt(52) if returns.std() > 0 else 0
+        peak = df['End Balance'].cummax()
+        dd = (peak - df['End Balance']) / peak
+        max_dd = dd.max() * 100 if not dd.empty else 0
+        final = df['End Balance'].iloc[-1] if not df.empty else config['starting_balance']
+        score = final / (1 + max_dd)
+        leaderboard.append({
+            "Strategy": name,
+            "Final Balance": round(final, 2),
+            "Max DD %": round(max_dd, 2),
+            "Sharpe": round(sharpe, 2),
+            "EdgeCast Score": round(score, 2)
+        })
+    return pd.DataFrame(leaderboard).sort_values("EdgeCast Score", ascending=False).reset_index(drop=True)
+
+# 🎛️ Gradio Interface Tabs
+preset_tab = gr.Interface(
+    fn=lambda style: simulate_tp_strategy_full(**strategy_presets[style]),
+    inputs=gr.Dropdown(choices=list(strategy_presets.keys()), label="Choose Preset Strategy"),
+    outputs=["dataframe", "json"],
+    title="🎯 Preset Mode",
+)
+
+manual_tab = gr.Interface(
+    fn=run_manual_simulation,
+    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, 3, 1.0, step=0.1, label="TP1 R"),
+        gr.Slider(0.1, 5, 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.Image()],
+    title="🥊 Battle Mode"
 )
 
+analytics_tab = gr.Interface(fn=analytics_dashboard, inputs=[], outputs="dataframe", title="📊 Analytics")
+
+# 🧠 Multi-tab UI
+gr.TabbedInterface(
+    interface_list=[preset_tab, manual_tab, battle_tab, analytics_tab],
+    tab_names=["🎯 Preset", "🛠️ Manual", "🥊 Battle", "📊 Analytics"],
+    title="EdgeCast – Strategy Simulation Suite"
+).launch()
 
-if __name__ == "__main__":
-    demo.launch()