cc-orderbook-python/orderbook.py at master · olned/cc-orderbook-python · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
from time import time

from half_book import HalfSnap


class L2OrderBook:
    handle_time = None
    on_changed = None

    def __init__(self, instrument: str):
        self.instrument = instrument
        self._bids = HalfSnap(True)
        self._asks = HalfSnap(False)

    def is_empty(self):
        return len(self.bids) == 0

    @property
    def bids(self):
        return self._bids.data

    @property
    def asks(self):
        return self._asks.data

    def get_side(self, side: str):
        if side == 'bids' or side == 'buy':
            return self._bids
        elif side == 'asks' or side == 'sell':
            return self._asks
        else:
            return None

    def set_snapshot(self, message):
        self.asks.clear()
        self.bids.clear()
        for item in message[1]:
            price = item[2]
            if price < 0:
                self.asks.add([item[0], -price])
            else:
                self.bids.add([item[0], price])

    def set_l2update(self, message):
        price = message[1][0]
        size = message[1][2]
        count = message[1][1]
        if size < 0:
            if count == 0:
                self._asks.update(price, 0.)
            else:
                self._asks.update(price, -size)
        else:
            if count == 0:
                self._bids.update(price, 0.)
            else:
                self._bids.update(price, size)

    def handle_message(self, message):
        if isinstance(message[1][0], list):
            self.set_snapshot(message)
        elif isinstance(message[1][0], str):
            pass
        else:
            self.set_l2update(message)
            return True

        return False

    async def handle_subscription(self, message, sender):
        start_at = time() * 1000
        server_time = message[-1]
        if self.handle_message(message):
            if self.handle_time:
                self.handle_time(server_time, sender.receipt_time * 1000, start_at, time() * 1000)

            await self.on_changed(self)

    async def subscribe_book(self, conn, handle_time, on_changed=None):
        self.handle_time = handle_time
        self.on_changed = on_changed
        await conn.subscribe({
            "channel": "book",
            "symbol": self.instrument
        }, handler=self.handle_subscription)