Update app/main.py

app/main.py

@@ -1,8 +1,8 @@
 """
-Sentinel Arbitrage Engine - v19.0 FINAL (Correct Mounting Architecture)
+Sentinel Arbitrage Engine - v20.0 FINAL (Raw Stream)
 
-This version uses the official, correct architecture for combining FastAPI and
-Socket.IO, resolving the 'mount' attribute error permanently.
+This version uses a file-based log and a raw, unstoppable streaming
+endpoint to guarantee signal delivery. This is the final architecture.
 """
 import asyncio
 import os
@@ -10,26 +10,35 @@ import json
 import time
 from contextlib import asynccontextmanager
 from datetime import datetime, timezone
-
 import httpx
-import socketio
 from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
+from fastapi.responses import StreamingResponse
 
-# --- RELATIVE IMPORTS ---
-# This assumes your project is structured with an 'app' package.
 from .price_fetcher import PriceFetcher
 from .arbitrage_analyzer import ArbitrageAnalyzer
 
 OPPORTUNITY_THRESHOLD = 0.0015
+SIGNALS_FILE = "signals.log"
 
-# --- SOCKET.IO SERVER SETUP ---
-# Create the server instance that will handle all real-time communication.
-sio = socketio.AsyncServer(async_mode='asgi', cors_allowed_origins='*')
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    if os.path.exists(SIGNALS_FILE): os.remove(SIGNALS_FILE)
+    
+    async with httpx.AsyncClient() as client:
+        price_fetcher = PriceFetcher(client)
+        arbitrage_analyzer = ArbitrageAnalyzer(client)
+        
+        app.state.engine_task = asyncio.create_task(
+            run_arbitrage_detector(price_fetcher, arbitrage_analyzer)
+        )
+        print("🚀 Sentinel Engine v20.0 (Raw Stream) is ONLINE.")
+        yield
+        app.state.engine_task.cancel()
+        print("✅ Engine shut down.")
 
-# --- BACKGROUND ENGINE ---
 async def run_arbitrage_detector(price_fetcher, analyzer):
-    """The core engine loop; detects opportunities and emits them via Socket.IO."""
+    """The core engine loop; writes signals to a log file."""
     while True:
         try:
             await price_fetcher.update_prices_async()
@@ -41,47 +50,47 @@ async def run_arbitrage_detector(price_fetcher, analyzer):
                     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}
-                            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()}
-                                await sio.emit('new_signal', signal)
-                                print(f"✅ Signal Emitted for {asset}: {signal['strategy']}")
+                                # --- THE FIX: Append as a single line to a log file ---
+                                with open(SIGNALS_FILE, "a") as f:
+                                    f.write(json.dumps(signal) + "\n")
+                                print(f"✅ Signal LOGGED for {asset}")
         except Exception as e:
             print(f"❌ ERROR in engine loop: {e}")
         await asyncio.sleep(15)
 
-# --- FASTAPI APP & LIFESPAN ---
-# This is the correct way to manage the background task with Socket.IO
-@sio.on('connect')
-async def connect(sid, environ):
-    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...")
-        # Note: We create clients here as they are not easily shared across lifespan contexts
-        price_fetcher = PriceFetcher(httpx.AsyncClient())
-        arbitrage_analyzer = ArbitrageAnalyzer(httpx.AsyncClient())
-        sio.background_task = sio.start_background_task(run_arbitrage_detector, price_fetcher, arbitrage_analyzer)
-
-@sio.on('disconnect')
-def disconnect(sid):
-    print(f"🔥 Client disconnected: {sid}")
+# --- FastAPI App Setup ---
+app = FastAPI(lifespan=lifespan)
 
-# --- FINAL APP ASSEMBLY ---
-# 1. Create the main FastAPI instance.
-app = FastAPI()
-
-# 2. Create the Socket.IO ASGI application.
-socket_app = socketio.ASGIApp(sio)
+@app.get("/api/signals/stream")
+async def signal_stream():
+    """This endpoint streams the content of the signals.log file line by line."""
+    async def event_generator():
+        # Use an async-compatible way to tail the file
+        try:
+            with open(SIGNALS_FILE, 'r') as f:
+                f.seek(0, 2) # Go to the end of the file
+                while True:
+                    line = f.readline()
+                    if not line:
+                        await asyncio.sleep(0.5) # Wait for new lines
+                        continue
+                    # Stream the line to the client
+                    yield line
+        except FileNotFoundError:
+            print("signals.log not created yet, client connected early.")
+            # Keep the connection open and wait for the file to be created
+            while not os.path.exists(SIGNALS_FILE):
+                await asyncio.sleep(1)
+            # Re-run the generator now that the file exists
+            yield from event_generator()
 
-# 3. Mount the Socket.IO app onto the FastAPI app at the correct path.
-app.mount("/socket.io", socket_app)
+    return StreamingResponse(event_generator(), media_type="text/plain")
 
-# 4. Mount the StaticFiles directory to serve index.html at the root.
 app.mount("/", StaticFiles(directory="static", html=True), name="static")