Update app/app.py

app/app.py

@@ -1,235 +1,90 @@
 """
-Sentinel of debugging. The logs from our previous sessions showed the backend was working, so this points to a subtle but critical failure in the final Arbitrage Engine - v15.0 (Brute-Force Edition)
+Sentinel Arbitrage Engine - v15.0 OMEGA (Socket.IO Perfected)
 
-This version uses a file-based log for link: the real-time connection between the backend and the frontend.
-
-This situation calls for a definitive, "n absolute signal persistence and
-a high-frequency polling mechanism for guaranteed data delivery.
+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.
 """
 import asyncio
 import os
 import json
-from contextlib import asynccontextmanager
+import time
 from datetime import datetime, timezone
+
 import httpx
-from fastapi import FastAPI, Requestuke it from orbit" solution. We are going to abandon the complex real-time protocols that have proven unreliable in this specific
-from fastapi.responses import HTMLResponse
+import socketio
+from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
 
-from .price_fetcher import PriceFetcher environment and switch to a simpler, more forceful method that is guaranteed to work.
-
-### The Creative Solution: The "
+from .price_fetcher import PriceFetcher
 from .arbitrage_analyzer import ArbitrageAnalyzer
 
-OPPORTUNITY_THRESHOLD = 0.001Brute Force" Polling Engine
-
-We will re-architect the application to be brutally simple and unstoppable.
+OPPORTUNITY_THRESHOLD = 0.0015
 
-**5
-SIGNALS_FILE = "signals.json"
+# --- Socket.IO Server Setup ---
+# We create the server instance that will manage all real-time communication.
+sio = socketio.AsyncServer(async_mode='asgi', cors_allowed_origins='*')
 
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # Clear the log on startup for a fresh session
-    if os.path.exists(SIGNALS_The "Wow" Factor:**
-This isn't about fancy protocols anymore; it's about raw, undeniable resultsFILE):
-        os.remove(SIGNALS_FILE)
-    
-    async with httpx.AsyncClient.
-1.  **Persistent Signal Log:** The backend will no longer use a fragile in-memory queue. It() as client:
-        app.state.price_fetcher = PriceFetcher(client)
-        app.state.arbitrage_analyzer = ArbitrageAnalyzer(client)
-        
-        arbitrage_task = asyncio. will write every signal it generates directly to a `signals.json` file. This is our new, permanent, audcreate_task(
-            run_arbitrage_detector(app.state.price_fetcher, app.state.arbitrage_analyzer)
-        )
-        
-        print("🚀 Sentinel Arbitrage Engine v15itable "database" of opportunities.
-2.  **Unstoppable Frontend:** The frontend will abandon WebSockets and SSE entirely.0 (Brute-Force) started.")
-        yield
-        
-        print("⏳ Shutting down engine. It will use a simple, powerful HTMX polling mechanism to fetch the *entire contents* of the `signals.json...")
-        arbitrage_task.cancel()
-        try: await arbitrage_task
-        except asyncio.Cancelled` file every 2 seconds and re-render the table. This is a "brute force" method that is immuneError: print("Engine shut down gracefully.")
+# --- FastAPI App Setup ---
+# The FastAPI app is now simpler. It only serves the static files.
+app = FastAPI()
+app.mount("/", StaticFiles(directory="static", html=True), name="static")
 
-async def run_arbitrage_detector(price_fetcher, to the connection and state-sharing bugs we've faced.
-3.  **The P/L Ticker analyzer):
-    """The core engine loop. Detects opportunities and writes them to a file."""
+# --- Background Engine ---
+async def run_arbitrage_detector(price_fetcher, analyzer):
+    """The core engine loop. Detects opportunities and emits them via Socket.IO."""
     while True:
         try:
             await price_fetcher.update_prices_async()
-            all_prices =:** We will add a "Simulated Profit/Loss" ticker that calculates the total hypothetical profit from all the signals found price_fetcher.get_all_prices()
+            all_prices = price_fetcher.get_all_prices()
             
-            for asset, prices in all_prices.items, providing a tangible "money-spinning" metric.
-
-This architecture is less elegant, but it is far more robust():
+            for asset, prices in all_prices.items():
                 pyth_price = prices.get("pyth")
                 chainlink_price = prices.get("chainlink_agg")
                 
-                if pyth_price and chainlink_price and pyth and is guaranteed to get the data onto the screen.
-
----
-
-### Step 1: The File-Based `app_price > 0:
-                    spread = abs(pyth_price - chainlink_price) / chain/main.py` (Definitive Rewrite)
-
-This version writes signals directly to a file and serves it via a simple APIlink_price
+                if pyth_price and chainlink_price and pyth_price > 0:
+                    spread = abs(pyth_price - chainlink_price) / chainlink_price
                     if spread > OPPORTUNITY_THRESHOLD:
-                        opportunity = {
-                            "asset": asset endpoint.
-
-**Replace `app/main.py` with this:**
-```python
-"""
-Sentinel Arbitrage, "pyth_price": pyth_price,
-                            "chainlink_price": chainlink_price Engine - v15.0 FINAL (File-Based & Unbreakable)
-
-This version uses a file-based log for, "spread_pct": spread * 100
-                        }
-                        briefing = await analyzer.get_alpha_briefing(asset, opportunity)
-                        if briefing:
-                            signal = {**opportunity, ** absolute signal persistence and
-a high-frequency polling mechanism for guaranteed data delivery.
-"""
-import asyncio
-import osbriefing, "timestamp": datetime.now(timezone.utc).isoformat()}
-                            
-                            # --- THE
-import json
-import time
-from contextlib import asynccontextmanager
-from datetime import datetime, timezone
-import htt CORE FIX: Write signal directly to the JSON file ---
-                            current_signals = []
-                            try:
-                               px
-from fastapi import FastAPI, Request
-from fastapi.responses import FileResponse, HTMLResponse
-from fastapi.staticfiles import Static with open(SIGNALS_FILE, 'r') as f:
-                                    current_signals = json.loadFiles
-
-from .price_fetcher import PriceFetcher
-from .arbitrage_analyzer import ArbitrageAnalyzer
-
-OPPORTUNITY_THRESHOLD = 0.0015
-SIGNALS_FILE = "signals.json"
-
-@asynccontext(f)
-                            except (FileNotFoundError, json.JSONDecodeError):
-                                pass # File doesn't existmanager
-async def lifespan(app: FastAPI):
-    # Clear the log on startup for a fresh session
-    if os yet or is empty
-                            
-                            current_signals.insert(0, signal) # Prepend new signal
-                            
-                            with open(SIGNALS_FILE, 'w') as f:
-                                json.dump(current_signals, f)
-                            
-                            print(f"✅ Signal LOGGED for {asset}: {signal['spread_pct']:.3f}%")
+                        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']}")
         except Exception as e:
             print(f"❌ ERROR in engine loop: {e}")
 
         await asyncio.sleep(15)
 
-# --- FastAPI App Setup ---
-app = FastAPI(lifes.path.exists(SIGNALS_FILE):
-        os.remove(SIGNALS_FILE)
-    
-pan=lifespan)
-
-# --- API Endpoint to serve the signals ---
-@app.get("/api/signals",    async with httpx.AsyncClient() as client:
-        app.state.price_fetcher = Price response_class=HTMLResponse)
-async def get_signals_table():
-    """Reads the signals file and renders theFetcher(client)
-        app.state.arbitrage_analyzer = ArbitrageAnalyzer(client)
-        
- entire table body."""
-    try:
-        with open(SIGNALS_FILE, 'r') as f:        arbitrage_task = asyncio.create_task(
-            run_arbitrage_detector(app.state
-            signals = json.load(f)
-    except (FileNotFoundError, json.JSONDecodeError):
-        signals.price_fetcher, app.state.arbitrage_analyzer)
+# --- Socket.IO Lifespan Events ---
+# This is the CORRECT way to manage background tasks with python-socketio.
+@sio.on('connect')
+async def connect(sid, environ):
+    print(f"✅ Client connected: {sid}")
+    # Start the engine only when the first user connects.
+    if sio.background_task is None:
+        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
         )
-        
-        print(" = []
-
-    if not signals:
-        return HTMLResponse('<tr id="placeholder-row"><td colspan="7🚀 Sentinel Arbitrage Engine v15.0 (File-Based) started.")
-        yield
-        
-        " style="text-align:center;">Monitoring for arbitrage opportunities...</td></tr>')
 
-    table_rows_htmlprint("⏳ Shutting down engine...")
-        arbitrage_task.cancel()
-        try: await arbitrage_task
-        except asyncio.CancelledError: print("Engine shut down gracefully.")
-
-async def run_arbitrage_detector(price = []
-    total_profit = 0
-    for s in signals:
-        is_pyth__fetcher, analyzer):
-    """The core engine loop. Detects opportunities and writes them to a file."""
-cheaper = s['pyth_price'] < s['chainlink_price']
-        profit = abs(    while True:
-        try:
-            await price_fetcher.update_prices_async()
-            s['chainlink_price'] - s['pyth_price'])
-        total_profit += profit * (all_prices = price_fetcher.get_all_prices()
-            
-            for asset, prices in all_prices.items():
-                pyth_price = prices.get("pyth")
-                chainlink_1 - 0.002) # Assume 0.2% total fees
-
-        table_rows_html.append(f"""
-        <tr>
-            <td>{datetime.fromisoformat(s['timestamp']).strftime('%Hprice = prices.get("chainlink_agg")
-                
-                if pyth_price and chainlink_:%M:%S')}</td>
-            <td><strong>{s['asset']}/USD</strong></td>
-            <td><spanprice and pyth_price > 0:
-                    spread = abs(pyth_price - chainlink_ class="{'buy' if is_pyth_cheaper else 'sell'}">${s["pyth_priceprice) / chainlink_price
-                    if spread > OPPORTUNITY_THRESHOLD:
-                        opportunity = {
-                            "]:,.2f}</span></td>
-            <td><span class="{'sell' if is_pyth_che"asset": asset, "pyth_price": pyth_price,
-                            "chainlink_price": chainlink_price, "spread_pct": spread * 100
-                        }
-                        briefing = await analyzer.get_alpha_briefing(asset, opportunity)
-                        if briefing:
-                            signal = {**opportunity, **briefing, "timestamp": datetime.now(timezone.utc).isoformat()}
-                            
-aper else 'buy'}">${s["chainlink_price"]:,.2f}</span></td>
-            <td><strong                            # --- THE FIX: Write signal directly to the JSON file ---
-                            current_signals = []
-                            if class="buy">{s['spread_pct']:.3f}%</strong></td>
-            <td><span class="risk-{s.get('risk', 'low').lower()}">{s.get('risk', 'N/A')} os.path.exists(SIGNALS_FILE):
-                                with open(SIGNALS_FILE, 'r')</span></td>
-            <td>{s.get('strategy', 'N/A')}</td>
-        </tr>
-        """) as f:
-                                    try:
-                                        current_signals = json.load(f)
-                                    
-    
-    profit_html = f'<span id="pnl-ticker" hx-swap-oob="except json.JSONDecodeError:
-                                        pass # File might be empty or corrupt
-                            
-                            current_signals.true">Simulated P/L: <span style="color: #34D399;">${totalinsert(0, signal) # Prepend new signal
-                            
-                            with open(SIGNALS_FILE, '_profit:,.2f}</span></span>'
-
-    return HTMLResponse(profit_html + "".join(table_w') as f:
-                                json.dump(current_signals, f)
-                            
-                            print(f"✅ Signal LOGGED for {asset}: {signal['spread_pct']:.3f}%")
-        exceptrows_html))
-
-# This single mount point serves index.html for the root path "/"
-app.mount("/", Exception as e:
-            print(f"❌ ERROR in engine loop: {e}")
+@sio.on('disconnect')
+def disconnect(sid):
+    print(f"🔥 Client disconnected: {sid}")
 
-        await asyncio. StaticFiles(directory="static", html=True), name="static")
+# --- Final ASGI App ---
+# We wrap the FastAPI app (for static files) and the Socket.IO app together.
+# The Socket.IO server is the primary application.
+combined_app = socketio.ASGIApp(sio, other_asgi_app=app)