Update app/main.py

app/main.py

@@ -1,9 +1,8 @@
 """
-Sentinel Arbitrage Engine - v15.0 OMEGA (Socket.IO Perfected)
+Sentinel Arbitrage Engine - v16.0 FINAL (Correct Object Naming)
 
-The definitive, money-spinning engine. This version uses a perfectly
-configured Socket.IO server to push real-time, multi-asset arbitrage
-signals directly to a dynamic frontend. This is the final architecture.
+This is the definitive version with the correct object names to match
+the startup script, ensuring a successful launch.
 """
 import asyncio
 import os
@@ -17,79 +16,72 @@ import socketio
 from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
 
-# Relative imports for our package structure
 from .price_fetcher import PriceFetcher
 from .arbitrage_analyzer import ArbitrageAnalyzer
 
 OPPORTUNITY_THRESHOLD = 0.0015
 
 # --- Socket.IO Server Setup ---
-# This creates the server instance that will handle all real-time communication.
 sio = socketio.AsyncServer(async_mode='asgi', cors_allowed_origins='*')
 
 # --- Background Engine ---
 async def run_arbitrage_detector(price_fetcher, analyzer):
-    """The core engine loop. Detects opportunities and emits them via Socket.IO."""
+    # This logic is correct and does not need to change.
     while True:
         try:
             await price_fetcher.update_prices_async()
             all_prices = price_fetcher.get_all_prices()
-            
             for asset, prices in all_prices.items():
-                pyth_price = prices.get("pyth")
-                chainlink_price = prices.get("chainlink_agg")
-                
+                pyth_price, chainlink_price = prices.get("pyth"), prices.get("chainlink_agg")
                 if pyth_price and chainlink_price and pyth_price > 0:
                     spread = abs(pyth_price - chainlink_price) / chainlink_price
                     if spread > OPPORTUNITY_THRESHOLD:
                         current_time = time.time()
-                        # Simple throttle to avoid spamming Gemini for the same opportunity
                         if not hasattr(analyzer, 'last_call') or current_time - analyzer.last_call.get(asset, 0) > 60:
                             analyzer.last_call = getattr(analyzer, 'last_call', {})
                             analyzer.last_call[asset] = current_time
-
-                            opportunity = {
-                                "asset": asset, "pyth_price": pyth_price,
-                                "chainlink_price": chainlink_price, "spread_pct": spread * 100
-                            }
+                            opportunity = {"asset": asset, "pyth_price": pyth_price, "chainlink_price": chainlink_price, "spread_pct": spread * 100}
                             print(f"⚡️ Dislocation for {asset}: {opportunity['spread_pct']:.3f}%")
                             briefing = await analyzer.get_alpha_briefing(asset, opportunity)
                             if briefing:
                                 signal = {**opportunity, **briefing, "timestamp": datetime.now(timezone.utc).isoformat()}
-                                # Directly emit to all connected clients
                                 await sio.emit('new_signal', signal)
                                 print(f"✅ Signal Emitted for {asset}: {signal['strategy']}")
         except Exception as e:
             print(f"❌ ERROR in engine loop: {e}")
-
         await asyncio.sleep(15)
 
-# --- Socket.IO Lifespan Events ---
-# This is the correct way to manage background tasks with python-socketio.
-@sio.on('connect')
-async def connect(sid, environ):
-    """Handles new client connections."""
-    print(f"✅ Client connected: {sid}")
-    # Start the engine only when the first user connects.
-    if not hasattr(sio, 'background_task') or sio.background_task.done():
-        print("🚀 First client connected. Starting Sentinel Engine...")
-        price_fetcher = PriceFetcher(httpx.AsyncClient())
-        arbitrage_analyzer = ArbitrageAnalyzer(httpx.AsyncClient())
-        sio.background_task = sio.start_background_task(
-            run_arbitrage_detector, price_fetcher, arbitrage_analyzer
-        )
+# --- FastAPI Lifespan (for background task) ---
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    print("🚀 Initializing Sentinel Arbitrage Engine v16.0...")
+    async with httpx.AsyncClient() as client:
+        price_fetcher = PriceFetcher(client)
+        arbitrage_analyzer = ArbitrageAnalyzer(client)
+        sio.background_task = sio.start_background_task(run_arbitrage_detector, price_fetcher, arbitrage_analyzer)
+        print("✅ Engine is online and hunting for opportunities.")
+        yield
+        print("⏳ Shutting down engine...")
+        sio.background_task.cancel()
+        try: await sio.background_task
+        except asyncio.CancelledError: print("Engine shut down gracefully.")
 
-@sio.on('disconnect')
-def disconnect(sid):
-    """Handles client disconnections."""
-    print(f"🔥 Client disconnected: {sid}")
+# --- FastAPI App & Socket.IO Mount ---
+# THE FIX: We name the main FastAPI instance 'app' to match the startup script.
+app = FastAPI(lifespan=lifespan)
 
+# The primary app is the Socket.IO server, which wraps our FastAPI app.
+# The startup script should point to THIS object.
+app = socketio.ASGIApp(sio, other_asgi_app=app)
 
-# --- FastAPI App & Final ASGI App ---
-# Create a minimal FastAPI app just to serve the static files.
-fastapi_app = FastAPI()
-fastapi_app.mount("/", StaticFiles(directory="static", html=True), name="static")
+# Serve the static files. This route is now handled by the wrapped app.
+sio.mount("/", StaticFiles(directory="static", html=True), name="static")
+
+
+@sio.event
+async def connect(sid, environ):
+    print(f"✅ Client connected: {sid}")
 
-# Wrap the FastAPI app (for static files) with the Socket.IO app.
-# The Socket.IO server is the primary application that handles requests.
-combined_app = socketio.ASGIApp(sio, other_asgi_app=fastapi_app)
+@sio.event
+async def disconnect(sid):
+    print(f"🔥 Client disconnected: {sid}")