Update app.py

app.py

@@ -1,155 +1,108 @@
 import gradio as gr
 import random
-import pandas as pd
 import plotly.graph_objects as go
 
-# --- SIMULATION STATE ---
-class MarketSimulation:
-    def __init__(self):
-        self.reset()
-        
-    def reset(self):
-        self.balance = 10000.0
-        self.shares = 0
-        self.avg_buy_price = 0.0
-        self.stock_price = 100.0
-        self.price_history = [100.0]
-        self.market_modes = ["Bull 📈", "Bear 📉", "Sideways ➡️"]
-        self.current_mode = "Sideways ➡️"
-        self.tick_counter = 0
+# We use a simple dict for state to keep Hugging Face happy
+init_state = {
+    "balance": 10000.0,
+    "shares": 0,
+    "avg_buy_price": 0.0,
+    "stock_price": 100.0,
+    "price_history": [100.0],
+    "current_mode": "Sideways ➡️",
+    "tick_counter": 0
+}
 
-    def tick(self):
-        self.tick_counter += 1
-        
-        # V2: Shift market regimes every 15 seconds
-        if self.tick_counter % 15 == 0:
-            self.current_mode = random.choice(self.market_modes)
+def tick(state):
+    state["tick_counter"] += 1
+    
+    # Change market modes
+    if state["tick_counter"] % 15 == 0:
+        state["current_mode"] = random.choice(["Bull 📈", "Bear 📉", "Sideways ➡️"])
+    
+    # Percentage calculation
+    base_move = random.uniform(-0.03, 0.03)
+    if state["current_mode"] == "Bull 📈":
+        base_move += random.uniform(0.005, 0.02)
+    elif state["current_mode"] == "Bear 📉":
+        base_move -= random.uniform(0.005, 0.02)
         
-        # Base volatility (percentage-based)
-        base_move = random.uniform(-0.03, 0.03) # ±3%
+    if random.random() < 0.02: # Black swan
+        base_move += random.choice([-0.08, 0.08])
         
-        # Apply regime bias
-        if self.current_mode == "Bull 📈":
-            base_move += random.uniform(0.005, 0.02)  # Upward bias
-        elif self.current_mode == "Bear 📉":
-            base_move -= random.uniform(0.005, 0.02)  # Downward bias
-            
-        # Occasional "Black Swan" shock move (2% chance)
-        if random.random() < 0.02:
-            base_move += random.choice([-0.08, 0.08]) # Sudden ±8% spike
-            
-        # Calculate new price
-        self.stock_price = max(1.0, round(self.stock_price * (1 + base_move), 2))
-        self.price_history.append(self.stock_price)
+    state["stock_price"] = max(1.0, round(state["stock_price"] * (1 + base_move), 2))
+    state["price_history"].append(state["stock_price"])
+    if len(state["price_history"]) > 30:
+        state["price_history"].pop(0)
         
-        # Keep history manageable
-        if len(self.price_history) > 40:
-            self.price_history.pop(0)
-            
-        return self.get_status(), self.update_chart()
-
-    def buy_stock(self):
-        if self.balance >= self.stock_price:
-            # Buy max possible shares for simplicity, or just 10 shares
-            shares_to_buy = min(10, int(self.balance // self.stock_price))
-            if shares_to_buy > 0:
-                total_cost = shares_to_buy * self.stock_price
-                
-                # Recalculate average buy price
-                total_shares = self.shares + shares_to_buy
-                self.avg_buy_price = ((self.shares * self.avg_buy_price) + total_cost) / total_shares
-                
-                self.shares += shares_to_buy
-                self.balance -= total_cost
-        return self.get_status(), self.update_chart()
-
-    def sell_stock(self):
-        if self.shares > 0:
-            shares_to_sell = min(10, self.shares)
-            total_revenue = shares_to_sell * self.stock_price
-            self.shares -= shares_to_sell
-            self.balance += total_revenue
-            if self.shares == 0:
-                self.avg_buy_price = 0.0
-        return self.get_status(), self.update_chart()
+    return state, *get_ui_updates(state)
 
-    def get_status(self):
-        # Calculate Profit/Loss
-        current_value = self.shares * self.stock_price
-        cost_basis = self.shares * self.avg_buy_price
-        pnl = current_value - cost_basis
-        pnl_string = f"+${pnl:,.2f}" if pnl >= 0 else f"-${abs(pnl):,.2f}"
-        
-        portfolio_value = self.balance + current_value
-        
-        return (
-            f"${self.balance:,.2f}",
-            f"${self.stock_price:,.2f}",
-            f"{self.shares}",
-            f"${self.avg_buy_price:,.2f}",
-            pnl_string,
-            f"${portfolio_value:,.2f}",
-            f"Current Regime: {self.current_mode}"
-        )
+def buy_stock(state):
+    if state["balance"] >= state["stock_price"]:
+        shares_to_buy = min(10, int(state["balance"] // state["stock_price"]))
+        if shares_to_buy > 0:
+            total_cost = shares_to_buy * state["stock_price"]
+            total_shares = state["shares"] + shares_to_buy
+            state["avg_buy_price"] = ((state["shares"] * state["avg_buy_price"]) + total_cost) / total_shares
+            state["shares"] = total_shares
+            state["balance"] -= total_cost
+    return state, *get_ui_updates(state)
 
-    def update_chart(self):
-        fig = go.Figure()
-        fig.add_trace(go.Scatter(
-            y=self.price_history, 
-            mode='lines+markers',
-            line=dict(color='#2196F3', width=3),
-            marker=dict(size=6),
-            name='Price'
-        ))
-        fig.update_layout(
-            title="Live Stock Price (Updates Every Second)",
-            xaxis_title="Time (Ticks)",
-            yaxis_title="Price ($)",
-            template="plotly_dark",
-            margin=dict(l=20, r=20, t=40, b=20),
-            height=350
-        )
-        return fig
+def sell_stock(state):
+    if state["shares"] > 0:
+        shares_to_sell = min(10, state["shares"])
+        state["balance"] += shares_to_sell * state["stock_price"]
+        state["shares"] -= shares_to_sell
+        if state["shares"] == 0:
+            state["avg_buy_price"] = 0.0
+    return state, *get_ui_updates(state)
 
-# --- GRADIO INTERFACE ---
-sim = MarketSimulation()
+def get_ui_updates(state):
+    pnl = (state["shares"] * state["stock_price"]) - (state["shares"] * state["avg_buy_price"])
+    pnl_str = f"+${pnl:,.2f}" if pnl >= 0 else f"-${abs(pnl):,.2f}"
+    net_worth = state["balance"] + (state["shares"] * state["stock_price"])
+    
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(y=state["price_history"], mode='lines+markers', line=dict(color='#2196F3', width=3)))
+    fig.update_layout(template="plotly_dark", margin=dict(l=10, r=10, t=10, b=10), height=300)
+    
+    return (
+        f"${state['balance']:,.2f}",
+        f"${state['stock_price']:,.2f}",
+        str(state["shares"]),
+        f"${state['avg_buy_price']:,.2f}",
+        pnl_str,
+        f"${net_worth:,.2f}",
+        f"Market: {state['current_mode']}",
+        fig
+    )
 
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 📈 PaperTrader Sim V2")
-    gr.Markdown("A pure-Python live market sandbox. Watch out for regime shifts and black swan shocks!")
+    gr.Markdown("# 📈 StockSim")
+    state = gr.State(default=init_state.copy())
     
     with gr.Row():
         with gr.Column(scale=2):
-            chart = gr.Plot(value=sim.update_chart())
-            regime_display = gr.Markdown("Current Regime: Sideways ➡️")
-            
+            chart = gr.Plot()
+            regime_display = gr.Markdown("Market: Sideways ➡️")
         with gr.Column(scale=1):
-            gr.Markdown("### 💰 Account & Portfolio")
-            total_net_worth = gr.Textbox(label="Total Net Worth", value="$10,000.00", interactive=False)
-            balance_box = gr.Textbox(label="Cash Balance", value="$10,000.00", interactive=False)
-            shares_box = gr.Textbox(label="Shares Owned", value="0", interactive=False)
-            avg_price_box = gr.Textbox(label="Avg Buy Price", value="$0.00", interactive=False)
-            pnl_box = gr.Textbox(label="Profit / Loss", value="$0.00", interactive=False)
+            net_worth_box = gr.Textbox(label="Net Worth")
+            balance_box = gr.Textbox(label="Cash")
+            shares_box = gr.Textbox(label="Shares")
+            avg_box = gr.Textbox(label="Avg Cost")
+            pnl_box = gr.Textbox(label="P&L")
 
     with gr.Row():
-        btn_buy = gr.Button("🛒 BUY 10 SHARES", variant="primary")
-        btn_sell = gr.Button("💵 SELL 10 SHARES", variant="secondary")
-        btn_reset = gr.Button("🔄 Reset Simulation")
+        btn_buy = gr.Button("BUY 10", variant="primary")
+        btn_sell = gr.Button("SELL 10", variant="secondary")
 
-    # Connect UI Components
-    status_outputs = [balance_box, gr.Textbox(visible=False), shares_box, avg_price_box, pnl_box, total_net_worth, regime_display]
+    outputs = [balance_box, gr.Textbox(visible=False), shares_box, avg_box, pnl_box, net_worth_box, regime_display, chart]
     
-    btn_buy.click(sim.buy_stock, outputs=[status_outputs[0], status_outputs[2], status_outputs[3], status_outputs[4], status_outputs[5], status_outputs[6], chart])
-    btn_sell.click(sim.sell_stock, outputs=[status_outputs[0], status_outputs[2], status_outputs[3], status_outputs[4], status_outputs[5], status_outputs[6], chart])
+    btn_buy.click(buy_stock, inputs=[state], outputs=[state] + outputs)
+    btn_sell.click(sell_stock, inputs=[state], outputs=[state] + outputs)
     
-    def reset_ui():
-        sim.reset()
-        return sim.get_status() + (sim.update_chart(),)
-        
-    btn_reset.click(reset_ui, outputs=[balance_box, gr.Textbox(visible=False), shares_box, avg_price_box, pnl_box, total_net_worth, regime_display, chart])
-
-    # The magic engine: Trigger a tick every 1.0 second automatically
+    # Timer updates state explicitly
     timer = gr.Timer(1.0)
-    timer.tick(sim.tick, outputs=[balance_box, gr.Textbox(visible=False), shares_box, avg_price_box, pnl_box, total_net_worth, regime_display, chart])
+    timer.tick(tick, inputs=[state], outputs=[state] + outputs)
 
 demo.launch()