Update app.py

app.py

@@ -97,25 +97,17 @@ def calculate_micro_price_structure(diff_x, diff_y_net, current_mid, best_bid, b
     }
 
 def calculate_polr(bids, asks, mid):
-    """
-    Path of Least Resistance:
-    Simulates eating volume on both sides. 
-    """
     if not bids or not asks: return []
 
-    sorted_bids = sorted(bids.items(), key=lambda x: -x[0]) # High to Low
-    sorted_asks = sorted(asks.items(), key=lambda x: x[0])  # Low to High
+    sorted_bids = sorted(bids.items(), key=lambda x: -x[0])
+    sorted_asks = sorted(asks.items(), key=lambda x: x[0])
 
     path_points = []
-    
-    # MODIFIED: Increased to 60 steps for high resolution
-    # Steps from 0.5 BTC up to 30.0 BTC
     volume_steps = [i * 0.5 for i in range(1, 61)] 
     
     current_time = time.time()
     
     for i, target_vol in enumerate(volume_steps):
-        # 1. Find price cost to eat 'target_vol' UP
         ask_cost_dist = 0
         cum_vol = 0
         target_ask_price = mid
@@ -126,7 +118,6 @@ def calculate_polr(bids, asks, mid):
                 break
         ask_cost_dist = target_ask_price - mid
 
-        # 2. Find price cost to eat 'target_vol' DOWN
         bid_cost_dist = 0
         cum_vol = 0
         target_bid_price = mid
@@ -137,21 +128,11 @@ def calculate_polr(bids, asks, mid):
                 break
         bid_cost_dist = mid - target_bid_price
 
-        # 3. Compare Resistance
         if bid_cost_dist <= 0: bid_cost_dist = 0.01
         if ask_cost_dist <= 0: ask_cost_dist = 0.01
 
         projected_p = mid
         if ask_cost_dist > bid_cost_dist:
-             # UP is harder (more distance for same vol), so price slides to bid
-             # Conventional logic: Price takes path of least resistance.
-             # If ask is thin (low dist), bid is thick (high dist) -> price goes up.
-             # Here: Ask Dist > Bid Dist means Ask is THINNER? No.
-             # Distance = Price Impact. 
-             # High Distance = High Impact = THIN Liquidity.
-             # Low Distance = Low Impact = THICK Liquidity.
-             # Price moves towards THIN liquidity (Least Resistance).
-             # So if Ask Cost Dist > Bid Cost Dist, Ask is THIN. Price goes UP.
              projected_p = target_ask_price 
         else:
              projected_p = target_bid_price
@@ -228,7 +209,6 @@ def process_market_data():
         {"bids": bid_walls, "asks": ask_walls}
     )
     
-    # Calculate Path of Least Resistance
     polr_path = calculate_polr(market_state['bids'], market_state['asks'], mid)
 
     if analysis:
@@ -475,15 +455,12 @@ HTML_PAGE = f"""
 
         const priceChart = LightweightCharts.createChart(document.getElementById('tv-price'), chartOpts);
         
-        // --- POLR RIVER INITIALIZATION ---
-        // Creating 60 distinct series for high resolution flow
         const polrLines = [];
-        const polrCount = 60; // Matches backend
+        const polrCount = 60; 
         
         for(let i=0; i<polrCount; i++) {{
-            // Calculate opacity: Nearest = 1.0, Furthest = 0.05
             const opacity = 1.0 - (i / (polrCount + 5)); 
-            const color = `rgba(213, 0, 249, ${{opacity.toFixed(2)}})`; // Purple fade
+            const color = `rgba(213, 0, 249, ${{opacity.toFixed(2)}})`; 
             
             polrLines.push(
                 priceChart.addLineSeries({{
@@ -496,7 +473,6 @@ HTML_PAGE = f"""
                 }})
             );
         }}
-        // --------------------------------
 
         const priceSeries = priceChart.addLineSeries({{ color: '#2979ff', lineWidth: 2, title: 'Price' }}); 
         const predSeries = priceChart.addLineSeries({{ color: '#ffeb3b', lineWidth: 2, lineStyle: 2, title: 'Math Forecast' }});
@@ -564,7 +540,6 @@ HTML_PAGE = f"""
                     const lastTime = cleanHist[cleanHist.length-1].time;
                     dom.ticker.innerText = lastP.toLocaleString('en-US', {{ minimumFractionDigits: 2 }});
 
-                    // 1. Yellow Line (Math Forecast)
                     if (data.analysis) {{
                         const proj = data.analysis.projected;
                         const rho = data.analysis.rho; 
@@ -572,7 +547,6 @@ HTML_PAGE = f"""
                             cleanHist[cleanHist.length-1],
                             {{ time: lastTime + 60, value: proj }}
                         ]);
-                        // Text updates
                         const pct = ((proj - lastP) / lastP) * 100;
                         const sign = pct >= 0 ? "+" : "";
                         dom.projPct.innerText = `${{sign}}${{pct.toFixed(4)}}%`;
@@ -582,7 +556,6 @@ HTML_PAGE = f"""
                         dom.score.style.color = rho > 0 ? "var(--green)" : (rho < 0 ? "var(--red)" : "var(--text-main)");
                     }}
 
-                    // 2. Purple River (POLR)
                     if (data.polr && data.polr.length) {{
                         data.polr.forEach((point, index) => {{
                             if (index < polrLines.length) {{
@@ -658,4 +631,189 @@ HTML_PAGE = f"""
     }});
 </script>
 </body>
-</html>
+</html>
+"""
+
+async def kraken_worker():
+    global market_state
+    try:
+        async with aiohttp.ClientSession() as session:
+            url = "https://api.kraken.com/0/public/OHLC?pair=XBTUSD&interval=1"
+            async with session.get(url) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    if 'result' in data:
+                        for key in data['result']:
+                            if key != 'last':
+                                raw_candles = data['result'][key]
+                                market_state['ohlc_history'] = [
+                                    {
+                                        'time': int(c[0]),
+                                        'open': float(c[1]),
+                                        'high': float(c[2]),
+                                        'low': float(c[3]),
+                                        'close': float(c[4])
+                                    }
+                                    for c in raw_candles[-120:]
+                                ]
+                                break
+    except Exception as e:
+        logging.error(f"History fetch failed: {e}")
+
+    while True:
+        try:
+            async with websockets.connect("wss://ws.kraken.com/v2") as ws:
+                logging.info(f"🔌 Connected to Kraken ({SYMBOL_KRAKEN})")
+                
+                await ws.send(json.dumps({
+                    "method": "subscribe",
+                    "params": {"channel": "book", "symbol": [SYMBOL_KRAKEN], "depth": 500}
+                }))
+                await ws.send(json.dumps({
+                    "method": "subscribe",
+                    "params": {"channel": "trade", "symbol": [SYMBOL_KRAKEN]}
+                }))
+                await ws.send(json.dumps({
+                    "method": "subscribe",
+                    "params": {"channel": "ohlc", "symbol": [SYMBOL_KRAKEN], "interval": 1}
+                }))
+
+                async for message in ws:
+                    payload = json.loads(message)
+                    channel = payload.get("channel")
+                    data = payload.get("data", [])
+
+                    if channel == "book":
+                        for item in data:
+                            for bid in item.get('bids', []):
+                                q, p = float(bid['qty']), float(bid['price'])
+                                if q == 0: market_state['bids'].pop(p, None)
+                                else: market_state['bids'][p] = q
+                            for ask in item.get('asks', []):
+                                q, p = float(ask['qty']), float(ask['price'])
+                                if q == 0: market_state['asks'].pop(p, None)
+                                else: market_state['asks'][p] = q
+                        
+                        if market_state['bids'] and market_state['asks']:
+                            best_bid = max(market_state['bids'].keys())
+                            best_ask = min(market_state['asks'].keys())
+                            mid = (best_bid + best_ask) / 2
+                            market_state['prev_mid'] = market_state['current_mid']
+                            market_state['current_mid'] = mid
+                            market_state['ready'] = True
+                            
+                            now = time.time()
+                            if not market_state['history'] or (now - market_state['history'][-1]['t'] > 0.5):
+                                market_state['history'].append({'t': now, 'p': mid})
+                                if len(market_state['history']) > HISTORY_LENGTH:
+                                    market_state['history'].pop(0)
+                    
+                    elif channel == "trade":
+                        for trade in data:
+                            try:
+                                qty = float(trade['qty'])
+                                price = float(trade['price'])
+                                side = trade['side']
+                                
+                                if side == 'buy': market_state['current_vol_window']['buy'] += qty
+                                else: market_state['current_vol_window']['sell'] += qty
+
+                                current_minute_start = int(time.time()) // 60 * 60
+                                
+                                if market_state['ohlc_history']:
+                                    last_candle = market_state['ohlc_history'][-1]
+                                    
+                                    if last_candle['time'] == current_minute_start:
+                                        last_candle['close'] = price
+                                        if price > last_candle['high']: last_candle['high'] = price
+                                        if price < last_candle['low']: last_candle['low'] = price
+                                    
+                                    elif current_minute_start > last_candle['time']:
+                                        new_candle = {
+                                            'time': current_minute_start,
+                                            'open': price,
+                                            'high': price,
+                                            'low': price,
+                                            'close': price
+                                        }
+                                        market_state['ohlc_history'].append(new_candle)
+                                        if len(market_state['ohlc_history']) > 200:
+                                            market_state['ohlc_history'].pop(0)
+                            except: pass
+
+                    elif channel == "ohlc":
+                        for candle in data:
+                            try:
+                                start_time = int(float(candle['endtime'])) - 60
+                                c_data = {
+                                    'time': start_time, 
+                                    'open': float(candle['open']),
+                                    'high': float(candle['high']),
+                                    'low': float(candle['low']),
+                                    'close': float(candle['close'])
+                                }
+                                
+                                if market_state['ohlc_history']:
+                                    if market_state['ohlc_history'][-1]['time'] == start_time:
+                                        market_state['ohlc_history'][-1] = c_data
+                                    elif market_state['ohlc_history'][-1]['time'] < start_time:
+                                        market_state['ohlc_history'].append(c_data)
+                                        if len(market_state['ohlc_history']) > 200:
+                                            market_state['ohlc_history'].pop(0)
+                            except Exception as e:
+                                pass
+
+        except Exception as e:
+            logging.warning(f"⚠️ Reconnecting: {e}")
+            await asyncio.sleep(3)
+
+async def broadcast_worker():
+    while True:
+        if connected_clients and market_state['ready']:
+            payload = process_market_data()
+            msg = json.dumps(payload)
+            for ws in list(connected_clients):
+                try: await ws.send_str(msg)
+                except: pass
+        await asyncio.sleep(BROADCAST_RATE)
+
+async def websocket_handler(request):
+    ws = web.WebSocketResponse()
+    await ws.prepare(request)
+    connected_clients.add(ws)
+    try:
+        async for msg in ws:
+            pass
+    finally:
+        connected_clients.remove(ws)
+    return ws
+
+async def handle_index(request):
+    return web.Response(text=HTML_PAGE, content_type='text/html')
+
+async def start_background(app):
+    app['kraken_task'] = asyncio.create_task(kraken_worker())
+    app['broadcast_task'] = asyncio.create_task(broadcast_worker())
+
+async def cleanup_background(app):
+    app['kraken_task'].cancel()
+    app['broadcast_task'].cancel()
+    try: await app['kraken_task']; await app['broadcast_task']
+    except: pass
+
+async def main():
+    app = web.Application()
+    app.router.add_get('/', handle_index)
+    app.router.add_get('/ws', websocket_handler)
+    app.on_startup.append(start_background)
+    app.on_cleanup.append(cleanup_background)
+    runner = web.AppRunner(app)
+    await runner.setup()
+    site = web.TCPSite(runner, '0.0.0.0', PORT)
+    await site.start()
+    print(f"🚀 Quant Dashboard: http://localhost:{PORT}")
+    await asyncio.Event().wait()
+
+if __name__ == "__main__":
+    try: asyncio.run(main())
+    except KeyboardInterrupt: pass