Update app/app.py

app/app.py

@@ -1,104 +1,90 @@
 """
-Sentinel Arbitrage Engine - v9.0 FINAL (Singleton Broker)
+Sentinel Arbitrage Engine - v10.0 OMEGA
 
-This version uses a singleton message broker to ensure robust, stateful
-communication between the background engine and the API endpoints.
+A complete architectural overhaul using FastAPI-SocketIO for guaranteed,
+real-time signal delivery. This is the definitive money-spinning engine.
 """
 import asyncio
 import os
 from contextlib import asynccontextmanager
 from datetime import datetime, timezone
-import json
 import httpx
-from fastapi import FastAPI, Request
-from fastapi.responses import HTMLResponse, StreamingResponse
-from fastapi.templating import Jinja2Templates
+import socketio
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
 
-# Import our local modules AND the new singleton broker
-from .price_fetcher import PriceFetcher
-from .arbitrage_analyzer import ArbitrageAnalyzer
-from .broker import signal_broker
+from price_fetcher import PriceFetcher
+from arbitrage_analyzer import ArbitrageAnalyzer
 
 OPPORTUNITY_THRESHOLD = 0.001
 
+# --- Socket.IO Server Setup ---
+sio = socketio.AsyncServer(async_mode='asgi', cors_allowed_origins='*')
+socket_app = socketio.ASGIApp(sio)
+
+# --- Application Lifespan ---
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    # We no longer need to manage the queue in the app state.
-    # The broker exists independently.
-    app.state.price_fetcher = PriceFetcher(httpx.AsyncClient())
-    app.state.arbitrage_analyzer = ArbitrageAnalyzer(httpx.AsyncClient())
+    print("🚀 Initializing Sentinel Arbitrage Engine v10.0...")
+    price_fetcher = PriceFetcher(httpx.AsyncClient())
+    arbitrage_analyzer = ArbitrageAnalyzer(httpx.AsyncClient())
     
-    arbitrage_task = asyncio.create_task(run_arbitrage_detector(app))
+    # Launch the engine as a background task, passing the Socket.IO server instance
+    arbitrage_task = asyncio.create_task(
+        run_arbitrage_detector(price_fetcher, arbitrage_analyzer)
+    )
     
-    print("🚀 Sentinel Arbitrage Engine v9.0 (Singleton Broker) started.")
+    print("✅ Engine is online and hunting for opportunities.")
     yield
     
     print("⏳ Shutting down engine...")
     arbitrage_task.cancel()
     try: await arbitrage_task
-    except asyncio.CancelledError: print("Engine shut down.")
+    except asyncio.CancelledError: print("Engine shut down gracefully.")
 
-async def run_arbitrage_detector(app: FastAPI):
-    # Now this function uses the globally imported signal_broker
+async def run_arbitrage_detector(price_fetcher, analyzer):
+    """The core engine loop. Now directly emits events via Socket.IO."""
     while True:
-        await app.state.price_fetcher.update_prices_async()
-        prices = app.state.price_fetcher.get_current_prices()
-        
-        pyth_price = prices.get("pyth")
-        chainlink_price = prices.get("chainlink_agg")
-        
-        if pyth_price and chainlink_price:
-            spread = abs(pyth_price - chainlink_price) / chainlink_price
-            if spread > OPPORTUNITY_THRESHOLD:
-                opportunity = {
-                    "id": f"{int(datetime.now().timestamp())}",
-                    "pyth_price": pyth_price, "chainlink_price": chainlink_price,
-                    "spread_pct": spread * 100
-                }
-                briefing = await app.state.arbitrage_analyzer.get_alpha_briefing(opportunity)
-                if briefing:
-                    signal = {**opportunity, **briefing, "timestamp": datetime.now(timezone.utc).isoformat()}
-                    # Put the signal into the singleton broker's queue
-                    await signal_broker.queue.put(signal)
-                    print(f"✅ Signal Queued: {signal['spread_pct']:.3f}% Discrepancy")
+        try:
+            await price_fetcher.update_prices_async()
+            prices = price_fetcher.get_current_prices()
+            
+            pyth_price = prices.get("pyth")
+            chainlink_price = prices.get("chainlink_agg")
+            
+            if pyth_price and chainlink_price:
+                spread = abs(pyth_price - chainlink_price) / chainlink_price
+                if spread > OPPORTUNITY_THRESHOLD:
+                    opportunity = {
+                        "pyth_price": pyth_price,
+                        "chainlink_price": chainlink_price,
+                        "spread_pct": spread * 100
+                    }
+                    print(f"⚡️ Discrepancy Detected: {opportunity['spread_pct']:.3f}%")
+                    briefing = await analyzer.get_alpha_briefing(opportunity)
+                    if briefing:
+                        signal = {**opportunity, **briefing, "timestamp": datetime.now(timezone.utc).isoformat()}
+                        # --- THE FIX: Directly emit to all connected clients ---
+                        await sio.emit('new_signal', signal)
+                        print(f"✅ Signal Emitted: {signal['strategy']}")
+        except Exception as e:
+            print(f"❌ ERROR in engine loop: {e}")
 
-        await asyncio.sleep(15) # Check every 15 seconds
+        await asyncio.sleep(15)
 
-app = FastAPI(title="Sentinel Arbitrage Engine", lifespan=lifespan)
-templates = Jinja2Templates(directory="templates")
+# --- FastAPI App Setup ---
+app = FastAPI(lifespan=lifespan)
 
-def render_signal_card(payload: dict) -> str:
-    # This rendering function remains the same
-    s = payload
-    time_str = datetime.fromisoformat(s['timestamp']).strftime('%H:%M:%S UTC')
-    pyth_class = "buy" if s['pyth_price'] < s['chainlink_price'] else "sell"
-    chainlink_class = "sell" if s['pyth_price'] < s['chainlink_price'] else "buy"
-    
-    return f"""
-    <tr id="trade-row-{s['id']}" hx-swap-oob="afterbegin:#opportunities-table">
-        <td><strong>BTC/USD</strong></td>
-        <td><span class="{pyth_class}">Pyth Network</span><br>${s['pyth_price']:,.2f}</td>
-        <td><span class="{chainlink_class}">Chainlink Agg.</span><br>${s['chainlink_price']:,.2f}</td>
-        <td><strong>{s['spread_pct']:.3f}%</strong></td>
-        <td><span class="risk-{s.get('risk', 'low').lower()}">{s.get('risk', 'N/A')}</span></td>
-        <td>{s.get('rationale', 'N/A')}</td>
-        <td><button class="trade-btn">{s.get('strategy', 'N/A')}</button></td>
-    </tr>
-    <div id="last-update-time" hx-swap-oob="true">{time_str}</div>
-    """
+# This serves the index.html and any other static files (like JS or CSS)
+app.mount("/", StaticFiles(directory="static", html=True), name="static")
+
+@sio.event
+async def connect(sid, environ):
+    print(f"✅ Client connected: {sid}")
 
-@app.get("/", response_class=HTMLResponse)
-async def serve_dashboard(request: Request):
-    return templates.TemplateResponse("index.html", {"request": request})
+@sio.event
+async def disconnect(sid):
+    print(f"🔥 Client disconnected: {sid}")
 
-@app.get("/api/signals/stream")
-async def signal_stream(request: Request):
-    # This endpoint now also imports and uses the singleton broker
-    async def event_generator():
-        while True:
-            # Get the signal from the singleton broker's queue
-            payload = await signal_broker.queue.get()
-            html_card = render_signal_card(payload)
-            data_payload = html_card.replace('\n', ' ').strip()
-            yield f"event: message\ndata: {data_payload}\n\n"
-    return StreamingResponse(event_generator(), media_type="text/event-stream")
+# Mount the Socket.IO app on top of the FastAPI app
+app.mount('/socket.io', socket_app)