Update app.py

app.py

@@ -4,7 +4,7 @@ import os
 import random
 import time
 from dataclasses import dataclass, asdict
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional
 
 from fastapi import FastAPI, Header, HTTPException, WebSocket, WebSocketDisconnect
 from fastapi.responses import FileResponse
@@ -13,17 +13,17 @@ from fastapi.responses import FileResponse
 # ----------------------------
 # Config
 # ----------------------------
-TICK_RATE = float(os.getenv("TICK_RATE", "1.0"))          # seconds
-MARKET_LENGTH = int(os.getenv("MARKET_LENGTH", "300"))    # number of ticks/days
+TICK_RATE = float(os.getenv("TICK_RATE", "1.0"))          # seconds per tick
+MARKET_LENGTH = int(os.getenv("MARKET_LENGTH", "600"))    # timeline length
 START_PRICE = float(os.getenv("START_PRICE", "100.0"))
 
 ADMIN_TOKEN = os.getenv("ADMIN_TOKEN", "")  # set as HF Space Secret
 ADMIN_HEADER = "X-ADMIN-TOKEN"
 
 INDEX_FILE = os.getenv("INDEX_FILE", "index.html")
-ADMIN_FILE = os.getenv("ADMIN_FILE", "admin.html")
+ADMIN_FILE = os.getenv("ADMIN_FILE", "admin.html")  # optional if you keep admin.html
 
-INITIAL_VOLATILITY = float(os.getenv("DEFAULT_VOLATILITY", "0.8"))
+DEFAULT_VOLATILITY = float(os.getenv("DEFAULT_VOLATILITY", "0.8"))
 
 
 # ----------------------------
@@ -32,40 +32,28 @@ INITIAL_VOLATILITY = float(os.getenv("DEFAULT_VOLATILITY", "0.8"))
 @dataclass
 class ScenarioEvent:
     day: int
-    shockPct: float = 0.0          # e.g. +5.0 means +5%
+    shockPct: float = 0.0          # price shock applied to future path from day onward
     volatility: Optional[float] = None
     news: Optional[str] = None
 
 
-@dataclass
-class Scenario:
-    name: str = "default"
-    startDay: int = 0
-    basePrice: float = START_PRICE
-    defaultVolatility: float = INITIAL_VOLATILITY
-    events: List[ScenarioEvent] = None
-
-
 # ----------------------------
 # Market simulator
 # ----------------------------
 class MarketSimulator:
-    def __init__(self, seed: int = 42, start_price: float = 100.0, base_vol: float = 0.8):
+    def __init__(self, seed: int = 42):
         self.seed = seed
-        self.start_price = start_price
-        self.base_vol = base_vol
 
-    def generate_base_market(self, length: int) -> List[Dict[str, float]]:
+    def generate_base_market(self, length: int, start_price: float, vol: float) -> List[Dict[str, float]]:
         rng = random.Random(self.seed)
-        price = self.start_price
-        series: List[Dict[str, float]] = []
+        price = float(start_price)
         drift = 0.02
 
+        series: List[Dict[str, float]] = []
         for i in range(length):
-            shock = rng.gauss(0.0, self.base_vol)
+            shock = rng.gauss(0.0, vol)
             price = max(1.0, price + drift + shock)
             series.append({"i": i, "close": round(price, 2)})
-
         return series
 
 
@@ -121,38 +109,33 @@ class ConnectionManager:
                     self.active.pop(cid, None)
 
     async def broadcast_tick(self, day: int) -> None:
-        payload = {
+        await self.broadcast({
             "type": "TICK",
             "payload": {
                 "day": day,
                 "leaderboard": await self._snapshot_leaderboard(),
             },
-        }
-        await self.broadcast(payload)
+        })
 
     async def broadcast_news(self, day: int, text: str) -> None:
-        payload = {"type": "NEWS", "payload": {"day": day, "text": text}}
-        await self.broadcast(payload)
+        await self.broadcast({"type": "NEWS", "payload": {"day": day, "text": text}})
 
 
-app = FastAPI(title="Trading Game (WebSocket + Admin)")
+app = FastAPI(title="MPTrading (FastAPI + WebSocket)")
 manager = ConnectionManager()
+sim = MarketSimulator(seed=42)
 
 # ----------------------------
 # Global game state
 # ----------------------------
 DAY_LOCK = asyncio.Lock()
-STATE_LOCK = asyncio.Lock()  # protects scenario/events/volatility/market
+STATE_LOCK = asyncio.Lock()
 
 CURRENT_DAY = 0
-CURRENT_VOL = INITIAL_VOLATILITY
-
-# Market is the "timeline" clients receive on INIT; we will adjust it when events happen.
-market_sim = MarketSimulator(seed=42, start_price=START_PRICE, base_vol=INITIAL_VOLATILITY)
-MARKET: List[Dict[str, float]] = market_sim.generate_base_market(MARKET_LENGTH)
+CURRENT_VOL = DEFAULT_VOLATILITY
 
-# Scheduled events by day
-EVENTS: Dict[int, List[ScenarioEvent]] = {}  # day -> [ScenarioEvent,...]
+MARKET: List[Dict[str, float]] = sim.generate_base_market(MARKET_LENGTH, START_PRICE, DEFAULT_VOLATILITY)
+EVENTS: Dict[int, List[ScenarioEvent]] = {}
 
 
 # ----------------------------
@@ -160,7 +143,6 @@ EVENTS: Dict[int, List[ScenarioEvent]] = {}  # day -> [ScenarioEvent,...]
 # ----------------------------
 def require_admin(token: Optional[str]) -> None:
     if not ADMIN_TOKEN:
-        # If not set, keep endpoints locked down by default.
         raise HTTPException(status_code=403, detail="Admin token not configured on server.")
     if token != ADMIN_TOKEN:
         raise HTTPException(status_code=401, detail="Invalid admin token.")
@@ -186,10 +168,6 @@ def snapshot_events() -> List[Dict[str, Any]]:
 
 
 def apply_price_shock_from_day(day: int, shock_pct: float) -> None:
-    """
-    Applies a multiplicative factor to MARKET[day:] so the event shifts the future path.
-    This matches the "future path shift" interpretation.
-    """
     if day < 0 or day >= len(MARKET):
         return
     factor = 1.0 + (shock_pct / 100.0)
@@ -197,9 +175,8 @@ def apply_price_shock_from_day(day: int, shock_pct: float) -> None:
         MARKET[i]["close"] = round(max(1.0, MARKET[i]["close"] * factor), 2)
 
 
-def regen_market_with_volatility(seed: int, start_price: float, base_vol: float) -> List[Dict[str, float]]:
-    sim = MarketSimulator(seed=seed, start_price=start_price, base_vol=base_vol)
-    return sim.generate_base_market(MARKET_LENGTH)
+def regen_market(start_price: float, vol: float) -> List[Dict[str, float]]:
+    return sim.generate_base_market(MARKET_LENGTH, start_price, vol)
 
 
 # ----------------------------
@@ -212,11 +189,14 @@ async def root():
 
 @app.get("/admin")
 async def admin_page():
+    # If you don't include admin.html, you can remove this endpoint.
+    if not os.path.exists(ADMIN_FILE):
+        raise HTTPException(status_code=404, detail="admin.html not found in repo root.")
     return FileResponse(ADMIN_FILE)
 
 
 # ----------------------------
-# Admin REST API
+# Admin REST API (unchanged)
 # ----------------------------
 @app.get("/admin/state")
 async def admin_state(x_admin_token: Optional[str] = Header(default=None, alias=ADMIN_HEADER)):
@@ -245,7 +225,6 @@ async def admin_clear_events(x_admin_token: Optional[str] = Header(default=None,
 async def admin_add_event(body: Dict[str, Any], x_admin_token: Optional[str] = Header(default=None, alias=ADMIN_HEADER)):
     require_admin(x_admin_token)
 
-    # Supports either "day" (absolute) or "offset" (relative to current day)
     async with DAY_LOCK:
         cur = CURRENT_DAY
 
@@ -260,7 +239,6 @@ async def admin_add_event(body: Dict[str, Any], x_admin_token: Optional[str] = H
         raise HTTPException(status_code=400, detail=f"Event day {day} is in the past (current day {cur}).")
 
     ev = parse_event({**body, "day": day})
-
     async with STATE_LOCK:
         EVENTS.setdefault(day, []).append(ev)
 
@@ -271,21 +249,18 @@ async def admin_add_event(body: Dict[str, Any], x_admin_token: Optional[str] = H
 async def admin_load_scenario(body: Dict[str, Any], x_admin_token: Optional[str] = Header(default=None, alias=ADMIN_HEADER)):
     require_admin(x_admin_token)
 
-    name = str(body.get("name", "scenario"))
     start_day = int(body.get("startDay", 0))
     base_price = float(body.get("basePrice", START_PRICE))
-    default_vol = float(body.get("defaultVolatility", INITIAL_VOLATILITY))
+    default_vol = float(body.get("defaultVolatility", DEFAULT_VOLATILITY))
     evs_raw = body.get("events", [])
     if not isinstance(evs_raw, list):
         raise HTTPException(status_code=400, detail="'events' must be a list.")
-
     evs = [parse_event(e) for e in evs_raw]
 
-    # Reset market + events, reset day, reset volatility
     async with STATE_LOCK:
         global MARKET, CURRENT_VOL
         CURRENT_VOL = default_vol
-        MARKET = regen_market_with_volatility(seed=42, start_price=base_price, base_vol=default_vol)
+        MARKET = regen_market(start_price=base_price, vol=default_vol)
         EVENTS.clear()
         for ev in evs:
             EVENTS.setdefault(ev.day, []).append(ev)
@@ -294,7 +269,7 @@ async def admin_load_scenario(body: Dict[str, Any], x_admin_token: Optional[str]
         global CURRENT_DAY
         CURRENT_DAY = max(0, min(start_day, len(MARKET) - 1))
 
-    return {"ok": True, "name": name, "startDay": CURRENT_DAY, "eventsLoaded": len(evs)}
+    return {"ok": True, "startDay": CURRENT_DAY, "eventsLoaded": len(evs)}
 
 
 # ----------------------------
@@ -304,7 +279,6 @@ async def admin_load_scenario(body: Dict[str, Any], x_admin_token: Optional[str]
 async def websocket_endpoint(websocket: WebSocket, client_id: str):
     await manager.connect(websocket, client_id)
 
-    # Send INIT immediately
     async with STATE_LOCK:
         init_payload = {"market": MARKET, "startDay": 0}
     await websocket.send_text(json.dumps({"type": "INIT", "payload": init_payload}))
@@ -330,7 +304,6 @@ async def websocket_endpoint(websocket: WebSocket, client_id: str):
                     roi_f = float(payload.get("roi", 0.0))
                 except Exception:
                     roi_f = 0.0
-
                 await manager.update_equity(name=name, equity=equity_f, roi=roi_f)
 
     except WebSocketDisconnect:
@@ -348,29 +321,24 @@ async def game_loop():
     while True:
         await asyncio.sleep(TICK_RATE)
 
-        # advance day
         async with DAY_LOCK:
             CURRENT_DAY = (CURRENT_DAY + 1) % len(MARKET)
             day = CURRENT_DAY
 
-        # apply scheduled events
         news_to_broadcast: List[str] = []
         async with STATE_LOCK:
             if day in EVENTS and EVENTS[day]:
                 for ev in EVENTS[day]:
                     if ev.shockPct:
-                        # shift entire future path from this day onwards
                         apply_price_shock_from_day(day, ev.shockPct)
                     if ev.volatility is not None:
                         CURRENT_VOL = float(ev.volatility)
                     if ev.news:
                         news_to_broadcast.append(ev.news)
 
-        # broadcast optional news first
         for text in news_to_broadcast:
             await manager.broadcast_news(day, text)
 
-        # broadcast tick
         await manager.broadcast_tick(day)