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
