Update app.py

app.py

@@ -108,9 +108,9 @@ def calculate_polr(bids, asks, mid):
 
     path_points = []
     
-    # MODIFIED: Reduced count to 15 distinct lines for performance/clarity
-    # Spaced out volume steps to capture depth
-    volume_steps = [i * 1.5 for i in range(1, 16)] 
+    # 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()
     
@@ -143,16 +143,21 @@ def calculate_polr(bids, asks, mid):
 
         projected_p = mid
         if ask_cost_dist > bid_cost_dist:
-             # UP is harder, Down is easier -> Price goes UP (slip is normally against liquidity, but POLR suggests price follows ease)
-             # Actually, conventionally POLR means price goes where resistance is lowest.
-             # If Ask side is THICK (High dist), and Bid side is THIN (Low dist), price falls.
-             # Logic revised for visualization: We project where price SLIPS to.
+             # 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
         
         path_points.append({
-            'index': i, # Mark the horizon index
+            'index': i, 
             'p': projected_p
         })
 
@@ -391,7 +396,7 @@ HTML_PAGE = f"""
 
     <div id="p-chart" class="panel">
         <div class="chart-header">
-            PRICE (BLUE) // <span class="c-purp">POLR RIVER (PURPLE FADE)</span> // <span style="color:var(--yellow)">PRED (YELLOW)</span>
+            PRICE (BLUE) // <span class="c-purp">POLR RIVER (HIGH RES)</span> // <span style="color:var(--yellow)">PRED (YELLOW)</span>
         </div>
         <div id="tv-price" style="flex: 1; width: 100%;"></div>
     </div>
@@ -471,13 +476,13 @@ HTML_PAGE = f"""
         const priceChart = LightweightCharts.createChart(document.getElementById('tv-price'), chartOpts);
         
         // --- POLR RIVER INITIALIZATION ---
-        // We create an array of series. Index 0 = Nearest Term, Index N = Long Term
+        // Creating 60 distinct series for high resolution flow
         const polrLines = [];
-        const polrCount = 15; // Matches backend
+        const polrCount = 60; // Matches backend
         
         for(let i=0; i<polrCount; i++) {{
-            // Calculate opacity: Nearest = 1.0, Furthest = 0.1
-            const opacity = 1.0 - (i / (polrCount + 2)); 
+            // 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
             
             polrLines.push(
@@ -578,10 +583,7 @@ HTML_PAGE = f"""
                     }}
 
                     // 2. Purple River (POLR)
-                    // We update each line individually based on the received array
                     if (data.polr && data.polr.length) {{
-                        // We use .update() here to build the history of the prediction lines
-                        // corresponding to the current time tick
                         data.polr.forEach((point, index) => {{
                             if (index < polrLines.length) {{
                                 polrLines[index].update({{
@@ -656,195 +658,4 @@ HTML_PAGE = f"""
     }});
 </script>
 </body>
-</html>
-"""
-
-async def kraken_worker():
-    global market_state
-    try:
-        # Fetch initial history
-        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']
-                                
-                                # Update Vol stats
-                                if side == 'buy': market_state['current_vol_window']['buy'] += qty
-                                else: market_state['current_vol_window']['sell'] += qty
-
-                                # LIVE CANDLE UPDATE
-                                current_minute_start = int(time.time()) // 60 * 60
-                                
-                                if market_state['ohlc_history']:
-                                    last_candle = market_state['ohlc_history'][-1]
-                                    
-                                    # If still in the same minute
-                                    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
-                                    
-                                    # If new minute started
-                                    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:
-                                # Kraken sends endtime, adjust to starttime
-                                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
+</html>