Spaces:

Alvin3y1
/

test

Sleeping

File size: 14,201 Bytes

import asyncio
import json
import logging
import time
import bisect
import random
from aiohttp import web
import websockets

# --- Configuration ---
SYMBOL_KRAKEN = "BTC/USD"
PORT = 7860
HISTORY_LENGTH = 300 

# --- Logging ---
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')

# --- In-Memory State ---
market_state = {
    "bids": {},
    "asks": {},
    "history": [],
    "current_mid": 0.0,
    "prev_mid": 0.0,
    "ready": False,
    "last_comment_time": 0
}

# --- AI Logic Helper ---
def generate_ai_commentary(diff_y, mid, prev_mid):
    if not diff_y:
        return {"text": "Initializing analysis...", "sentiment": "neutral", "net": 0}

    # 1. Calculate Aggregates
    net_total = diff_y[-1] # Total Net Liquidity at max depth
    
    # 2. Price Trend
    price_delta = mid - prev_mid
    
    # 3. Logic Engine
    msg = ""
    sentiment = "neutral"
    
    # -- SCENARIO 1: EXTREME IMBALANCE --
    if net_total > 50:
        sentiment = "bullish"
        msg = f"🚀 <b>STRONG BUY WALL:</b> Net surplus of {int(net_total)} BTC. Orderbook tilted heavily to Bids."
    elif net_total < -50:
        sentiment = "bearish"
        msg = f"📉 <b>HEAVY SELL WALL:</b> Net deficit of {int(net_total)} BTC. Sellers dominating."
    
    # -- SCENARIO 2: ABSORPTION (Price moving vs Liquidity) --
    elif price_delta < -5 and net_total > 20:
        sentiment = "warning"
        msg = f"🛡️ <b>ABSORPTION:</b> Price dropping, but Buyers are stepping in (+{int(net_total)} BTC surplus)."
    elif price_delta > 5 and net_total < -20:
        sentiment = "warning"
        msg = f"🧱 <b>RESISTANCE:</b> Price rising into Sell liquidity ({int(net_total)} BTC deficit)."

    # -- SCENARIO 3: CHOP / EQUILIBRIUM --
    elif abs(net_total) < 10:
        sentiment = "neutral"
        msg = f"⚖️ <b>EQUILIBRIUM:</b> Liquidity is balanced. Waiting for a breakout trigger."

    # -- SCENARIO 4: MOMENTUM --
    else:
        if net_total > 0:
            msg = f"📈 <b>Bullish Bias:</b> Moderate buy support (+{int(net_total)} BTC)."
            sentiment = "bullish"
        else:
            msg = f"📉 <b>Bearish Bias:</b> Moderate sell pressure ({int(net_total)} BTC)."
            sentiment = "bearish"

    return {"text": msg, "sentiment": sentiment, "net": net_total}

# --- HTML Frontend ---
HTML_PAGE = f"""
<!DOCTYPE html>
<html>
<head>
    <title>BTC-USD AI Hybrid Dashboard</title>
    <script src="https://cdn.plot.ly/plotly-2.24.1.min.js"></script>
    <style>
        body {{ margin: 0; padding: 0; background-color: #0e0e0e; color: #ccc; font-family: 'Courier New', monospace; overflow: hidden; }}
        
        /* Layout Grid */
        #container {{ display: flex; flex-direction: column; height: 100vh; width: 100vw; }}
        
        /* Row 1: Price & Vol */
        #row-top {{ flex: 1; display: flex; width: 100%; border-bottom: 1px solid #333; }}
        
        /* Row 2: Diff & AI */
        #row-bot {{ flex: 1; display: flex; width: 100%; }}
        
        .col {{ width: 50%; height: 100%; border-right: 1px solid #333; position: relative; }}
        .col-ai {{ width: 50%; height: 100%; background-color: #050505; display: flex; flex-direction: column; padding: 10px; overflow-y: auto; }}

        /* Terminal Styling */
        .terminal-header {{ color: #00bcd4; font-weight: bold; border-bottom: 1px dashed #333; padding-bottom: 5px; margin-bottom: 10px; }}
        .log-entry {{ margin-bottom: 8px; font-size: 13px; border-left: 3px solid transparent; padding-left: 8px; }}
        .log-time {{ color: #555; font-size: 11px; margin-right: 8px; }}
        
        /* Sentiments */
        .bullish {{ border-left-color: #00e676; color: #e8f5e9; }}
        .bearish {{ border-left-color: #ff1744; color: #ffebee; }}
        .neutral {{ border-left-color: #999; color: #ccc; }}
        .warning {{ border-left-color: #ff9800; color: #fff3e0; }}

        .chart {{ width: 100%; height: 100%; }}
        
        #status {{ position: absolute; top: 10px; left: 60px; z-index: 100; font-size: 14px; background: rgba(0,0,0,0.8); padding: 5px 10px; border-radius: 4px; border: 1px solid #333; }}
        .green {{ color: #00e676; }}
        .red {{ color: #ff1744; }}
    </style>
</head>
<body>
    <div id="status">Connecting...</div>
    
    <div id="container">
        <!-- ROW 1 -->
        <div id="row-top">
            <div class="col">
                <div id="price-chart" class="chart"></div>
            </div>
            <div class="col">
                <div id="vol-chart" class="chart"></div>
            </div>
        </div>

        <!-- ROW 2 -->
        <div id="row-bot">
            <div class="col">
                <!-- NET DIFFERENCE CHART -->
                <div id="diff-chart" class="chart"></div>
            </div>
            <div class="col-ai">
                <!-- AI TERMINAL -->
                <div class="terminal-header">> AI MARKET COMMENTARY</div>
                <div id="terminal-logs"></div>
            </div>
        </div>
    </div>

    <script>
        const priceDiv = document.getElementById('price-chart');
        const volDiv = document.getElementById('vol-chart');
        const diffDiv = document.getElementById('diff-chart');
        const termLogs = document.getElementById('terminal-logs');
        const statusDiv = document.getElementById('status');
        
        let initPrice = false, initVol = false, initDiff = false;
        let lastLogText = "";

        const commonConfig = {{ responsive: true, displayModeBar: false }};
        const commonLayout = {{
            paper_bgcolor: '#0e0e0e',
            plot_bgcolor: '#0e0e0e',
            font: {{ color: '#aaa', family: 'Courier New' }},
            margin: {{ t: 30, b: 25, l: 45, r: 20 }},
            showlegend: false,
            xaxis: {{ gridcolor: '#222' }},
            yaxis: {{ gridcolor: '#222' }}
        }};

        function addLog(data) {{
            if (data.comment.text === lastLogText) return;
            lastLogText = data.comment.text;

            const div = document.createElement('div');
            div.className = `log-entry ${{data.comment.sentiment}}`;
            const timeStr = new Date().toLocaleTimeString();
            div.innerHTML = `<span class="log-time">${{timeStr}}</span> ${{data.comment.text}}`;
            
            termLogs.prepend(div);
            if (termLogs.children.length > 25) termLogs.removeChild(termLogs.lastChild);
        }}

        async function updateCharts() {{
            try {{
                const res = await fetch('/data');
                const data = await res.json();

                if (data.error) {{
                    statusDiv.innerHTML = "Waiting for data...";
                    return;
                }}

                statusDiv.innerHTML = `Mid: <span class="${{data.mid >= data.prev_mid ? 'green' : 'red'}}">$${{data.mid.toLocaleString(undefined, {{minimumFractionDigits: 2}})}}</span>`;

                // 1. Price
                const tracePrice = {{ x: data.history.map(d=>new Date(d.t*1000)), y: data.history.map(d=>d.p), type: 'scatter', mode:'lines', line: {{color: '#29b6f6'}} }};
                if (!initPrice) {{ Plotly.newPlot(priceDiv, [tracePrice], {{ ...commonLayout, title: '<b>Midprice</b>', xaxis: {{type:'date', gridcolor:'#222'}} }}, commonConfig); initPrice = true; }}
                else {{ Plotly.react(priceDiv, [tracePrice], {{ ...commonLayout, title: '<b>Midprice</b>', xaxis: {{type:'date', gridcolor:'#222'}} }}, commonConfig); }}

                // 2. Volume
                const tracesVol = [
                    {{ x: data.vol.dist_bids, y: data.vol.vol_bids, type: 'scatter', name: 'Bid', line: {{color: '#00e676'}} }},
                    {{ x: data.vol.dist_asks, y: data.vol.vol_asks, type: 'scatter', name: 'Ask', line: {{color: '#ff1744'}} }}
                ];
                if (!initVol) {{ Plotly.newPlot(volDiv, tracesVol, {{ ...commonLayout, title: '<b>Cumulative Volume</b>', xaxis: {{title:'Distance ($)'}} }}, commonConfig); initVol = true; }}
                else {{ Plotly.react(volDiv, tracesVol, {{ ...commonLayout, title: '<b>Cumulative Volume</b>', xaxis: {{title:'Distance ($)'}} }}, commonConfig); }}

                // 3. Net Difference (Restored)
                const traceDiff = {{ 
                    x: data.diff.x, 
                    y: data.diff.y, 
                    type: 'scatter', 
                    mode: 'lines', 
                    fill: 'tozeroy', 
                    line: {{color: '#e040fb', width: 2}} 
                }};
                if (!initDiff) {{ Plotly.newPlot(diffDiv, [traceDiff], {{ ...commonLayout, title: '<b>Net Liquidity (Bids - Asks)</b>', xaxis: {{title:'Distance ($)'}} }}, commonConfig); initDiff = true; }}
                else {{ Plotly.react(diffDiv, [traceDiff], {{ ...commonLayout, title: '<b>Net Liquidity (Bids - Asks)</b>', xaxis: {{title:'Distance ($)'}} }}, commonConfig); }}

                // 4. AI Log
                addLog(data);

            }} catch (e) {{ console.error("Fetch error:", e); }}
        }}

        setInterval(updateCharts, 750);
    </script>
</body>
</html>
"""

async def kraken_worker():
    global market_state
    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}
                }))

                async for message in ws:
                    payload = json.loads(message)
                    channel = payload.get("channel")
                    data_entries = payload.get("data", [])

                    if channel == "book":
                        for item in data_entries:
                            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())
                            market_state['prev_mid'] = market_state['current_mid']
                            mid = (best_bid + best_ask) / 2
                            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)

        except Exception as e:
            logging.warning(f"⚠️ Reconnecting: {e}")
            await asyncio.sleep(3)

async def handle_index(request):
    return web.Response(text=HTML_PAGE, content_type='text/html')

async def handle_data(request):
    if not market_state['ready']:
        return web.json_response({"error": "Initializing..."})

    mid = market_state['current_mid']
    
    # --- Prepare Data ---
    raw_bids = sorted(market_state['bids'].items(), key=lambda x: -x[0])[:300]
    raw_asks = sorted(market_state['asks'].items(), key=lambda x: x[0])[:300]

    # Calculate Distances & Cum Volumes
    d_b_x, d_b_y, cum = [], [], 0
    for p, q in raw_bids:
        d = mid - p
        if d >= 0:
            cum += q
            d_b_x.append(d); d_b_y.append(cum)

    d_a_x, d_a_y, cum = [], [], 0
    for p, q in raw_asks:
        d = p - mid
        if d >= 0:
            cum += q
            d_a_x.append(d); d_a_y.append(cum)

    # --- Calculate Net Liquidity Array (Diff) ---
    diff_x, diff_y = [], []
    
    if d_b_x and d_a_x:
        max_dist = min(d_b_x[-1], d_a_x[-1])
        step_size = max_dist / 100
        steps = [i * step_size for i in range(1, 101)]
        
        for s in steps:
            idx_b = bisect.bisect_right(d_b_x, s)
            vol_b = d_b_y[idx_b-1] if idx_b > 0 else 0
            
            idx_a = bisect.bisect_right(d_a_x, s)
            vol_a = d_a_y[idx_a-1] if idx_a > 0 else 0
            
            val = vol_b - vol_a
            diff_x.append(s)
            diff_y.append(val)

    # --- Generate AI Commentary ---
    ai_output = generate_ai_commentary(diff_y, mid, market_state['prev_mid'])

    return web.json_response({
        "mid": mid,
        "prev_mid": market_state['prev_mid'],
        "vol": { "dist_bids": d_b_x, "vol_bids": d_b_y, "dist_asks": d_a_x, "vol_asks": d_a_y },
        "diff": { "x": diff_x, "y": diff_y },
        "comment": ai_output,
        "history": market_state['history']
    })

async def start_background(app):
    app['kraken_task'] = asyncio.create_task(kraken_worker())

async def cleanup_background(app):
    app['kraken_task'].cancel()
    try: await app['kraken_task']
    except asyncio.CancelledError: pass

async def main():
    app = web.Application()
    app.router.add_get('/', handle_index)
    app.router.add_get('/data', handle_data)
    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"🚀 BTC-USD AI+Graph Dashboard: http://localhost:{PORT}")
    await asyncio.Event().wait()

if __name__ == "__main__":
    try: asyncio.run(main())
    except KeyboardInterrupt: pass