def test_from_dict_returns_expected_tick(self): # Arrange order1 = Order(price=10, size=5, side=OrderSide.BUY, id="1") delta1 = OrderBookDelta( instrument_id=AUDUSD, book_type=BookType.L2_MBP, action=BookAction.ADD, order=order1, ts_event=0, ts_init=0, ) order2 = Order(price=10, size=15, side=OrderSide.BUY, id="2") delta2 = OrderBookDelta( instrument_id=AUDUSD, book_type=BookType.L2_MBP, action=BookAction.ADD, order=order2, ts_event=0, ts_init=0, ) deltas = OrderBookDeltas( instrument_id=AUDUSD, book_type=BookType.L2_MBP, deltas=[delta1, delta2], ts_event=0, ts_init=0, ) # Act result = OrderBookDeltas.from_dict(OrderBookDeltas.to_dict(deltas)) # Assert assert result == deltas
def test_update(): level = Level(price=10.0) order = Order(price=10.0, size=100.0, side=OrderSide.BUY) level.add(order) assert level.volume() == 100.0 order.update_size(size=50.0) level.update(order=order) assert level.volume() == 50.0
def test_exposure(): orders = [ Order(price=100.0, size=10.0, side=OrderSide.SELL), Order(price=101.0, size=10.0, side=OrderSide.SELL), Order(price=105.0, size=5.0, side=OrderSide.SELL), ] ladder = TestStubs.ladder(reverse=True, orders=orders) assert tuple(ladder.exposures()) == (525.0, 1000.0, 1010.0)
def test_delete_individual_order(asks): orders = [ Order(price=100.0, size=10.0, side=OrderSide.BUY, id="1"), Order(price=100.0, size=5.0, side=OrderSide.BUY, id="2"), ] ladder = TestStubs.ladder(reverse=True, orders=orders) ladder.delete(orders[0]) assert ladder.volumes() == [5.0]
def test_from_dict_returns_expected_order(): # Arrange order = Order(price=10, size=5, side=OrderSide.BUY) # Act result = Order.from_dict(Order.to_dict(order)) # Assert assert result == order
def test_delete_order(): level = Level(price=100.0) orders = [ Order(price=100.0, size=50.0, side=OrderSide.BUY, id="1"), Order(price=100.0, size=50.0, side=OrderSide.BUY, id="2"), ] level.bulk_add(orders=orders) level.delete(order=orders[1]) assert level.volume() == 50.0
def test_level_comparison(): level1 = Level(price=10.0) level2 = Level(price=11.0) level1.add(Order(price=10.0, size=0.0, side=OrderSide.BUY)) level2.add(Order(price=11.0, size=0.0, side=OrderSide.BUY)) assert level2 >= level1 assert level1 < level2 assert level1 != level2
def test_repr(): book = OrderBook.create( instrument=AUDUSD_SIM, book_type=BookType.L2_MBP, ) # Act book.add(Order(price=10.0, size=5.0, side=OrderSide.BUY)) book.add(Order(price=11.0, size=6.0, side=OrderSide.SELL)) # Assert assert isinstance(repr(book), str) # <-- calls pprint internally
def test_check_integrity_shallow(empty_l2_book): empty_l2_book.add(Order(price=10.0, size=5.0, side=OrderSide.SELL)) empty_l2_book.check_integrity() try: # Orders will be in cross empty_l2_book.add(Order(price=20.0, size=5.0, side=OrderSide.BUY)) except BookIntegrityError: # Catch the integrity exception and pass to allow the test pass with pytest.raises(BookIntegrityError): empty_l2_book.check_integrity()
def test_signed_volume(): order = Order(price=10.0, size=1.0, side=OrderSide.BUY) assert order.size == 1 and order.signed_size() == 1.0 order = Order(price=10.0, size=5.0, side=OrderSide.SELL) assert order.size == 5 and order.signed_size() == -5.0 order = Order(price=10.0, size=0.0, side=OrderSide.SELL) assert order.size == 0.0 and order.signed_size() == 0.0
def test_to_dict_returns_expected_dict(): # Arrange order = Order(price=10, size=5, side=OrderSide.BUY, id="1") # Act result = Order.to_dict(order) # Assert assert result == { "type": "Order", "id": "1", "price": 10.0, "side": "BUY", "size": 5.0, }
def parse_book_delta_ws( instrument_id: InstrumentId, side: OrderSide, delta: Tuple[str, str], ts_event: int, ts_init: int, update_id: int, ) -> OrderBookDelta: price = float(delta[0]) size = float(delta[1]) order = Order( price=price, size=size, side=side, ) return OrderBookDelta( instrument_id=instrument_id, book_type=BookType.L2_MBP, action=BookAction.UPDATE if size > 0.0 else BookAction.DELETE, order=order, ts_event=ts_event, ts_init=ts_init, update_id=update_id, )
def sample_book(): ob = L3OrderBook( instrument_id=TestStubs.audusd_id(), price_precision=5, size_precision=0, ) orders = [ Order(price=0.90000, size=20.0, side=OrderSide.SELL), Order(price=0.88700, size=10.0, side=OrderSide.SELL), Order(price=0.88600, size=5.0, side=OrderSide.SELL), Order(price=0.83000, size=4.0, side=OrderSide.BUY), Order(price=0.82000, size=1.0, side=OrderSide.BUY), ] for order in orders: ob.add(order) return ob
def test_apply(empty_l2_book, clock): snapshot = OrderBookSnapshot( instrument_id=empty_l2_book.instrument_id, book_type=BookType.L2_MBP, bids=[[150.0, 0.51]], asks=[[160.0, 1.51]], ts_event=0, ts_init=0, ) empty_l2_book.apply_snapshot(snapshot) assert empty_l2_book.best_ask_price() == 160 delta = OrderBookDelta( instrument_id=TestStubs.audusd_id(), book_type=BookType.L2_MBP, action=BookAction.ADD, order=Order( 155.0, 672.45, OrderSide.SELL, "4a25c3f6-76e7-7584-c5a3-4ec84808e240", ), ts_event=clock.timestamp(), ts_init=clock.timestamp(), ) empty_l2_book.apply(delta) assert empty_l2_book.best_ask_price() == 155
def test_to_dict_returns_expected_dict(self): # Arrange order = Order(price=10, size=5, side=OrderSide.BUY, id="1") delta = OrderBookDelta( instrument_id=AUDUSD, book_type=BookType.L2_MBP, action=BookAction.ADD, order=order, ts_event=0, ts_init=0, ) # Act result = OrderBookDelta.to_dict(delta) # Assert assert result == { "type": "OrderBookDelta", "instrument_id": "AUD/USD.SIM", "book_type": "L2_MBP", "action": "ADD", "order_id": "1", "order_price": 10.0, "order_side": "BUY", "order_size": 5.0, "update_id": 0, "ts_event": 0, "ts_init": 0, }
def test_add_orders_to_book(): # Arrange book = OrderBook.create( instrument=AUDUSD_SIM, book_type=BookType.L2_MBP, ) # Act book.add(Order(price=10.0, size=5.0, side=OrderSide.BUY)) book.add(Order(price=11.0, size=6.0, side=OrderSide.SELL)) # Assert assert book.best_bid_price() == 10.0 assert book.best_ask_price() == 11.0 assert book.best_bid_qty() == 5.0 assert book.best_ask_qty() == 6.0 assert book.spread() == 1
def test_simulate_order_fills_multiple_levels(asks): fills = asks.simulate_order_fills( order=Order(price=20, size=20, side=OrderSide.BUY, id="1")) expected = [ (Price.from_str("15.0000"), Quantity.from_str("10.0000")), (Price.from_str("16.0000"), Quantity.from_str("10.0000")), ] assert fills == expected
def test_hash_str_and_repr(): # Arrange order = Order(price=10, size=5, side=OrderSide.BUY) # Act, Assert assert isinstance(hash(order), int) assert str(order) == f"Order(10.0, 5.0, BUY, {order.id})" assert repr(order) == f"Order(10.0, 5.0, BUY, {order.id})"
def test_simulate_order_fills_whole_ladder(asks): fills = asks.simulate_order_fills( order=Order(price=100, size=1000, side=OrderSide.BUY, id="1")) expected = [ (Price.from_str("15.0000"), Quantity.from_str("10.0000")), (Price.from_str("16.0000"), Quantity.from_str("20.0000")), (Price.from_str("17.0000"), Quantity.from_str("30.0000")), ] assert fills == expected
def test_to_dict_returns_expected_dict(self): # Arrange order1 = Order(price=10, size=5, side=OrderSide.BUY, id="1") delta1 = OrderBookDelta( instrument_id=AUDUSD, book_type=BookType.L2_MBP, action=BookAction.ADD, order=order1, ts_event=0, ts_init=0, ) order2 = Order(price=10, size=15, side=OrderSide.BUY, id="2") delta2 = OrderBookDelta( instrument_id=AUDUSD, book_type=BookType.L2_MBP, action=BookAction.ADD, order=order2, ts_event=0, ts_init=0, ) deltas = OrderBookDeltas( instrument_id=AUDUSD, book_type=BookType.L2_MBP, deltas=[delta1, delta2], ts_event=0, ts_init=0, ) # Act result = OrderBookDeltas.to_dict(deltas) # Assert assert result == { "type": "OrderBookDeltas", "instrument_id": "AUD/USD.SIM", "book_type": "L2_MBP", "deltas": b'[{"type":"OrderBookDelta","instrument_id":"AUD/USD.SIM","book_type":"L2_MBP","action":"ADD","order_price":10.0,"order_size":5.0,"order_side":"BUY","order_id":"1","update_id":0,"ts_event":0,"ts_init":0},{"type":"OrderBookDelta","instrument_id":"AUD/USD.SIM","book_type":"L2_MBP","action":"ADD","order_price":10.0,"order_size":15.0,"order_side":"BUY","order_id":"2","update_id":0,"ts_event":0,"ts_init":0}]', # noqa "update_id": 0, "ts_event": 0, "ts_init": 0, }
def test_simulate_order_fills_l3(): ladder = Ladder(False, 4, 4) orders = [ Order(price=15, size=1, side=OrderSide.SELL, id="1"), Order(price=16, size=2, side=OrderSide.SELL, id="2"), Order(price=16, size=3, side=OrderSide.SELL, id="3"), Order(price=20, size=10, side=OrderSide.SELL, id="4"), ] for order in orders: ladder.add(order) fills = ladder.simulate_order_fills( order=Order(price=16.5, size=4, side=OrderSide.BUY, id="1")) expected = [ (Price.from_str("15.0000"), Quantity.from_str("1.0000")), (Price.from_str("16.0000"), Quantity.from_str("2.0000")), (Price.from_str("16.0000"), Quantity.from_str("1.0000")), ] assert fills == expected
def test_hash_str_and_repr(self): # Arrange order1 = Order(price=10, size=5, side=OrderSide.BUY, id="1") delta1 = OrderBookDelta( instrument_id=AUDUSD, book_type=BookType.L2_MBP, action=BookAction.ADD, order=order1, ts_event=0, ts_init=0, ) order2 = Order(price=10, size=15, side=OrderSide.BUY, id="2") delta2 = OrderBookDelta( instrument_id=AUDUSD, book_type=BookType.L2_MBP, action=BookAction.ADD, order=order2, ts_event=0, ts_init=0, ) deltas = OrderBookDeltas( instrument_id=AUDUSD, book_type=BookType.L2_MBP, deltas=[delta1, delta2], ts_event=0, ts_init=0, ) # Act, Assert assert isinstance(hash(deltas), int) assert ( str(deltas) == "OrderBookDeltas('AUD/USD.SIM', book_type=L2_MBP, [OrderBookDelta('AUD/USD.SIM', book_type=L2_MBP, action=ADD, order=Order(10.0, 5.0, BUY, 1), update_id=0, ts_event=0, ts_init=0), OrderBookDelta('AUD/USD.SIM', book_type=L2_MBP, action=ADD, order=Order(10.0, 15.0, BUY, 2), update_id=0, ts_event=0, ts_init=0)], update_id=0, ts_event=0, ts_init=0)" # noqa ) assert ( repr(deltas) == "OrderBookDeltas('AUD/USD.SIM', book_type=L2_MBP, [OrderBookDelta('AUD/USD.SIM', book_type=L2_MBP, action=ADD, order=Order(10.0, 5.0, BUY, 1), update_id=0, ts_event=0, ts_init=0), OrderBookDelta('AUD/USD.SIM', book_type=L2_MBP, action=ADD, order=Order(10.0, 15.0, BUY, 2), update_id=0, ts_event=0, ts_init=0)], update_id=0, ts_event=0, ts_init=0)" # noqa )
def parser(data): parsed = data if not isinstance(parsed, list): # print(parsed) return elif isinstance(parsed, list): channel, updates = parsed if not isinstance(updates[0], list): updates = [updates] else: raise KeyError() if isinstance(updates, int): print("Err", updates) return for values in updates: keys = ("order_id", "price", "size") data = dict(zip(keys, values)) side = OrderSide.BUY if data["size"] >= 0 else OrderSide.SELL if data["price"] == 0: yield dict( op="delete", order=Order( price=Price(data["price"], precision=10), size=Quantity(abs(data["size"]), precision=10), side=side, id=str(data["order_id"]), ), ) else: yield dict( op="update", order=Order( price=Price(data["price"], precision=10), size=Quantity(abs(data["size"]), precision=10), side=side, id=str(data["order_id"]), ), )
def test_top(empty_l2_book): empty_l2_book.add(Order(price=10.0, size=5.0, side=OrderSide.BUY)) empty_l2_book.add(Order(price=20.0, size=5.0, side=OrderSide.BUY)) empty_l2_book.add(Order(price=5.0, size=5.0, side=OrderSide.BUY)) empty_l2_book.add(Order(price=25.0, size=5.0, side=OrderSide.SELL)) empty_l2_book.add(Order(price=30.0, size=5.0, side=OrderSide.SELL)) empty_l2_book.add(Order(price=21.0, size=5.0, side=OrderSide.SELL)) assert empty_l2_book.best_bid_level().price == 20 assert empty_l2_book.best_ask_level().price == 21
def parse_line(d): if "status" in d: return {} elif "close_price" in d: # return {'timestamp': d['remote_timestamp'], "close_price": d['close_price']} return {} if "trade" in d: ts = millis_to_nanos( pd.Timestamp(d["remote_timestamp"]).timestamp()) return { "timestamp": d["remote_timestamp"], "op": "trade", "trade": TradeTick( instrument_id=InstrumentId(Symbol("TEST"), Venue("BETFAIR")), price=Price(d["trade"]["price"], 4), size=Quantity(d["trade"]["volume"], 4), aggressor_side=d["trade"]["side"], trade_id=TradeId(d["trade"]["trade_id"]), ts_event=ts, ts_init=ts, ), } elif "level" in d and d["level"]["orders"][0]["volume"] == 0: op = "delete" else: op = "update" order_like = d["level"]["orders"][0] if op != "trade" else d[ "trade"] return { "timestamp": d["remote_timestamp"], "op": op, "order": Order( price=Price(order_like["price"], precision=6), size=Quantity(abs(order_like["volume"]), precision=4), # Betting sides are reversed side={ 2: OrderSide.BUY, 1: OrderSide.SELL }[order_like["side"]], id=str(order_like["order_id"]), ), }
def test_orderbook_operation_update(empty_l2_book, clock): delta = OrderBookDelta( instrument_id=TestStubs.audusd_id(), book_type=BookType.L2_MBP, action=BookAction.UPDATE, order=Order( 0.5814, 672.45, OrderSide.SELL, "4a25c3f6-76e7-7584-c5a3-4ec84808e240", ), ts_event=clock.timestamp(), ts_init=clock.timestamp(), ) empty_l2_book.apply_delta(delta) assert empty_l2_book.best_ask_price() == 0.5814
def l1_feed(): provider = TestDataProvider() updates = [] for _, row in provider.read_csv_ticks("truefx-usdjpy-ticks.csv").iterrows(): for side, order_side in zip(("bid", "ask"), (OrderSide.BUY, OrderSide.SELL)): updates.append( { "op": "update", "order": Order( price=Price(row[side], precision=6), size=Quantity(1e9, precision=2), side=order_side, ), } ) return updates
def test_timestamp_ns(empty_l2_book, clock): delta = OrderBookDelta( instrument_id=TestStubs.audusd_id(), book_type=BookType.L2_MBP, action=BookAction.ADD, order=Order( 0.5900, 672.45, OrderSide.SELL, "4a25c3f6-76e7-7584-c5a3-4ec84808e240", ), ts_event=clock.timestamp(), ts_init=clock.timestamp(), ) empty_l2_book.apply_delta(delta) assert empty_l2_book.ts_last == delta.ts_init
def from_dict(values) -> "BSPOrderBookDelta": PyCondition.not_none(values, "values") action: BookAction = BookActionParser.from_str_py(values["action"]) order: Order = (Order.from_dict({ "price": values["order_price"], "size": values["order_size"], "side": values["order_side"], "id": values["order_id"], }) if values["action"] != "CLEAR" else None) return BSPOrderBookDelta( instrument_id=InstrumentId.from_str(values["instrument_id"]), book_type=BookTypeParser.from_str_py(values["book_type"]), action=action, order=order, ts_event=values["ts_event"], ts_init=values["ts_init"], )
def test_from_dict_returns_expected_delta(self): # Arrange order = Order(price=10, size=5, side=OrderSide.BUY) delta = OrderBookDelta( instrument_id=AUDUSD, book_type=BookType.L2_MBP, action=BookAction.ADD, order=order, ts_event=0, ts_init=0, ) # Act result = OrderBookDelta.from_dict(OrderBookDelta.to_dict(delta)) # Assert assert result == delta