async def listen_for_order_book_snapshots(self,
ev_loop: asyncio.BaseEventLoop,
output: asyncio.Queue):
while True:
try:
for trading_pair in self._trading_pairs:
snapshot: Dict[str, Any] = await self.get_snapshot(
trading_pair, domain=self._domain)
snapshot_timestamp: float = time.time()
snapshot_msg: OrderBookMessage = BinancePerpetualOrderBook.snapshot_message_from_exchange(
snapshot,
snapshot_timestamp,
metadata={"trading_pair": trading_pair})
output.put_nowait(snapshot_msg)
self.logger().debug(
f"Saved order book snapshot for {trading_pair}")
this_hour: pd.Timestamp = pd.Timestamp.utcnow().replace(
minute=0, second=0, microsecond=0)
next_hour: pd.Timestamp = this_hour + pd.Timedelta(hours=1)
delta: float = next_hour.timestamp() - time.time()
await self._sleep(delta)
except asyncio.CancelledError:
raise
except Exception:
self.logger().error(
"Unexpected error occurred fetching orderbook snapshots. Retrying in 5 seconds...",
exc_info=True)
await self._sleep(5.0)
async def listen_for_order_book_diffs(self, ev_loop: asyncio.BaseEventLoop,
output: asyncio.Queue):
while True:
try:
# trading_pairs: List[str] = await self.get_trading_pairs()
ws_subscription_path: str = "/".join([
f"{convert_to_exchange_trading_pair(trading_pair).lower()}@depth"
for trading_pair in self._trading_pairs
])
stream_url: str = f"{self._stream_url}?streams={ws_subscription_path}"
async with websockets.connect(stream_url) as ws:
ws: websockets.WebSocketClientProtocol = ws
async for raw_msg in self.ws_messages(ws):
msg_json = ujson.loads(raw_msg)
timestamp: float = time.time()
order_book_message: OrderBookMessage = BinancePerpetualOrderBook.diff_message_from_exchange(
msg_json, timestamp)
output.put_nowait(order_book_message)
except asyncio.CancelledError:
raise
except Exception:
self.logger().error(
"Unexpected error with Websocket connection. Retrying after 30 seconds... ",
exc_info=True)
await asyncio.sleep(30.0)
async def listen_for_order_book_snapshots(self,
ev_loop: asyncio.BaseEventLoop,
output: asyncio.Queue):
while True:
try:
for trading_pair in self._trading_pairs:
snapshot: Dict[str, Any] = await self.get_snapshot(
trading_pair,
domain=self._domain,
throttler=self._throttler,
api_factory=self._api_factory)
snapshot_timestamp: float = time.time()
snapshot_msg: OrderBookMessage = BinancePerpetualOrderBook.snapshot_message_from_exchange(
snapshot,
snapshot_timestamp,
metadata={"trading_pair": trading_pair})
output.put_nowait(snapshot_msg)
self.logger().debug(
f"Saved order book snapshot for {trading_pair}")
delta = CONSTANTS.ONE_HOUR - time.time() % CONSTANTS.ONE_HOUR
await self._sleep(delta)
except asyncio.CancelledError:
raise
except Exception:
self.logger().error(
"Unexpected error occurred fetching orderbook snapshots. Retrying in 5 seconds...",
exc_info=True)
await self._sleep(5.0)
async def listen_for_trades(self, ev_loop: asyncio.BaseEventLoop,
output: asyncio.Queue):
while True:
try:
ws_subscription_path: str = "/".join([
f"{convert_to_exchange_trading_pair(trading_pair).lower()}@aggTrade"
for trading_pair in self._trading_pairs
])
stream_url = f"{utils.wss_url(endpoint=CONSTANTS.PUBLIC_WS_ENDPOINT)}?streams={ws_subscription_path}"
ws: websockets.WebSocketClientProtocol = await websockets.connect(
stream_url)
async for raw_msg in self.ws_messages(ws):
msg_json = ujson.loads(raw_msg)
trade_msg: OrderBookMessage = BinancePerpetualOrderBook.trade_message_from_exchange(
msg_json)
output.put_nowait(trade_msg)
except asyncio.CancelledError:
raise
except Exception:
self.logger().error(
"Unexpected error with Websocket connection. Retrying after 30 seconds...",
exc_info=True)
await self._sleep(30.0)
finally:
await ws.close()
async def listen_for_trades(self, ev_loop: asyncio.BaseEventLoop,
output: asyncio.Queue):
ws = None
while True:
try:
ws = await self._create_websocket_connection()
payload = {
"method":
"SUBSCRIBE",
"params": [
f"{utils.convert_to_exchange_trading_pair(trading_pair).lower()}@aggTrade"
for trading_pair in self._trading_pairs
],
"id":
self.TRADE_STREAM_ID
}
await ws.send_json(payload)
async for json_msg in self._iter_messages(ws):
if "result" in json_msg:
continue
trade_msg: OrderBookMessage = BinancePerpetualOrderBook.trade_message_from_exchange(
json_msg)
output.put_nowait(trade_msg)
except asyncio.CancelledError:
raise
except Exception:
self.logger().error(
"Unexpected error with Websocket connection. Retrying after 30 seconds...",
exc_info=True)
await self._sleep(30.0)
finally:
ws and await ws.close()
async def listen_for_trades(self, ev_loop: asyncio.BaseEventLoop, output: asyncio.Queue):
while True:
msg = await self._message_queue[CONSTANTS.TRADE_STREAM_ID].get()
msg.data["data"]["s"] = await self.convert_from_exchange_trading_pair(
exchange_trading_pair=msg.data["data"]["s"],
domain=self._domain,
throttler=self._throttler)
trade_message: OrderBookMessage = BinancePerpetualOrderBook.trade_message_from_exchange(msg.data)
output.put_nowait(trade_message)
async def get_new_order_book(self, trading_pair: str) -> OrderBook:
snapshot: Dict[str, Any] = await self.get_snapshot(trading_pair, 1000, self._domain, self._throttler, self._api_factory)
snapshot_timestamp: float = time.time()
snapshot_msg: OrderBookMessage = BinancePerpetualOrderBook.snapshot_message_from_exchange(
snapshot, snapshot_timestamp, metadata={"trading_pair": trading_pair}
)
order_book = self.order_book_create_function()
order_book.apply_snapshot(snapshot_msg.bids, snapshot_msg.asks, snapshot_msg.update_id)
return order_book
async def listen_for_order_book_diffs(self, ev_loop: asyncio.BaseEventLoop, output: asyncio.Queue):
while True:
msg = await self._message_queue[CONSTANTS.DIFF_STREAM_ID].get()
timestamp: float = time.time()
msg.data["data"]["s"] = await self.convert_from_exchange_trading_pair(
exchange_trading_pair=msg.data["data"]["s"],
domain=self._domain,
throttler=self._throttler)
order_book_message: OrderBookMessage = BinancePerpetualOrderBook.diff_message_from_exchange(
msg.data, timestamp
)
output.put_nowait(order_book_message)
async def get_new_order_book(self, trading_pair: str) -> OrderBook:
async with aiohttp.ClientSession() as client:
snapshot: Dict[str, Any] = await self.get_snapshot(
client, trading_pair, 1000, self._base_url)
snapshot_timestamp: float = time.time()
snapshot_msg: OrderBookMessage = BinancePerpetualOrderBook.snapshot_message_from_exchange(
snapshot,
snapshot_timestamp,
metadata={"trading_pair": trading_pair})
order_book = self.order_book_create_function()
order_book.apply_snapshot(snapshot_msg.bids, snapshot_msg.asks,
snapshot_msg.update_id)
return order_book
