Enable Betfair book imbalance acceptance

- Replace the skipped v2 placeholder with a real Betfair run
- Use v2-native book deltas and an acceptance-local strategy
- Assert the expected order and position lifecycle

Author: cjdsellers

python/tests/acceptance/test_backtest.py

@@ -41,15 +41,23 @@
 from nautilus_trader.model import AccountType
 from nautilus_trader.model import AggressorSide
 from nautilus_trader.model import BarType
+from nautilus_trader.model import BettingInstrument
+from nautilus_trader.model import BookAction
+from nautilus_trader.model import BookOrder
+from nautilus_trader.model import BookType
 from nautilus_trader.model import Currency
 from nautilus_trader.model import ExecAlgorithmId
+from nautilus_trader.model import InstrumentId
 from nautilus_trader.model import Money
 from nautilus_trader.model import OmsType
+from nautilus_trader.model import OrderBookDelta
+from nautilus_trader.model import OrderBookDeltas
 from nautilus_trader.model import OrderSide
 from nautilus_trader.model import OrderStatus
 from nautilus_trader.model import Price
 from nautilus_trader.model import Quantity
 from nautilus_trader.model import QuoteTick
+from nautilus_trader.model import Symbol
 from nautilus_trader.model import TradeId
 from nautilus_trader.model import TradeTick
 from nautilus_trader.model import Venue
@@ -87,6 +95,9 @@
 EMA_CROSS_TRAILING_STOP_STRATEGY = "strategies.acceptance:EMACrossTrailingStop"
 EMA_CROSS_TRAILING_STOP_CONFIG = "strategies.acceptance:EMACrossTrailingStopConfig"
 
+ORDER_BOOK_IMBALANCE_STRATEGY = "strategies.acceptance:OrderBookImbalance"
+ORDER_BOOK_IMBALANCE_CONFIG = "strategies.acceptance:OrderBookImbalanceConfig"
+
 EMA_CROSS_TRAILING_STOP_TAG = "ema-cross-trailing-stop"
 
 
@@ -670,12 +681,119 @@ def test_run_ema_cross_with_tick_bar_spec(self):
         assert result.total_orders > 0
 
 
-@pytest.mark.skip(
-    reason="v2 missing: Betfair adapter / data provider + OrderBookImbalance strategy",
-)
 class TestBacktestAcceptanceTestsOrderBookImbalance:
+    def setup_method(self):
+        self.engine = _engine()
+        self.venue = Venue("BETFAIR")
+        self.gbp = Currency.from_str("GBP")
+        self.instrument = _betfair_betting_instrument(selection_id=19248890)
+
+        self.engine.add_venue(
+            venue=self.venue,
+            oms_type=OmsType.NETTING,
+            account_type=AccountType.BETTING,
+            base_currency=self.gbp,
+            starting_balances=[Money(100_000.0, self.gbp)],
+            book_type=BookType.L2_MBP,
+        )
+        self.engine.add_instrument(self.instrument)
+        self.engine.add_data(_betfair_order_book_deltas(self.instrument))
+
+    def teardown_method(self):
+        self.engine.dispose()
+
     def test_run_order_book_imbalance(self):
-        pass
+        self.engine.add_strategy_from_config(
+            ImportableStrategyConfig(
+                strategy_path=ORDER_BOOK_IMBALANCE_STRATEGY,
+                config_path=ORDER_BOOK_IMBALANCE_CONFIG,
+                config={
+                    "instrument_id": str(self.instrument.id),
+                    "trade_size": "5.00",
+                },
+            ),
+        )
+
+        self.engine.run()
+        result = self.engine.get_result()
+
+        assert result.iterations == 1
+        assert result.total_orders == 2
+        assert result.total_positions == 1
+        assert result.summary["venues.total"] == "1"
+        assert result.summary["orders.closed"] == "2"
+        assert result.summary["positions.closed"] == "1"
+
+
+def _betfair_betting_instrument(selection_id: int) -> BettingInstrument:
+    raw_symbol = Symbol(f"1-166811431-{selection_id}-None")
+    gbp = Currency.from_str("GBP")
+    return BettingInstrument(
+        instrument_id=InstrumentId(raw_symbol, Venue("BETFAIR")),
+        raw_symbol=raw_symbol,
+        event_type_id=6423,
+        event_type_name="American Football",
+        competition_id=12282733,
+        competition_name="NFL",
+        event_id=29678534,
+        event_name="NFL",
+        event_country_code="GB",
+        event_open_date=1644276600000000000,
+        betting_type="ODDS",
+        market_id="1-166811431",
+        market_name="AFC Conference Winner",
+        market_type="SPECIAL",
+        market_start_time=1644276600000000000,
+        selection_id=selection_id,
+        selection_name="Kansas City Chiefs",
+        selection_handicap=-9999999.0,
+        currency=gbp,
+        price_precision=2,
+        size_precision=2,
+        price_increment=Price.from_str("0.01"),
+        size_increment=Quantity.from_str("0.01"),
+        ts_event=0,
+        ts_init=0,
+    )
+
+
+def _betfair_order_book_deltas(instrument: BettingInstrument) -> list[OrderBookDeltas]:
+    ts = 1_600_000_000_000_000_000
+    return [
+        OrderBookDeltas(
+            instrument_id=instrument.id,
+            deltas=[
+                OrderBookDelta(
+                    instrument.id,
+                    BookAction.ADD,
+                    BookOrder(
+                        OrderSide.BUY,
+                        Price.from_decimal_dp(Decimal("1.99"), instrument.price_precision),
+                        Quantity.from_decimal_dp(Decimal("250.00"), instrument.size_precision),
+                        1,
+                    ),
+                    0,
+                    1,
+                    ts,
+                    ts,
+                ),
+                OrderBookDelta(
+                    instrument.id,
+                    BookAction.ADD,
+                    BookOrder(
+                        OrderSide.SELL,
+                        Price.from_decimal_dp(Decimal("2.00"), instrument.price_precision),
+                        Quantity.from_decimal_dp(Decimal("10.00"), instrument.size_precision),
+                        2,
+                    ),
+                    0,
+                    2,
+                    ts,
+                    ts,
+                ),
+            ],
+        ),
+    ]
 
 
 @pytest.mark.skip(reason="v2 missing: Betfair adapter + MarketMaker example strategy")

python/tests/strategies/acceptance.py

@@ -31,11 +31,13 @@
 from nautilus_trader.indicators import MovingAverageConvergenceDivergence
 from nautilus_trader.model import Bar
 from nautilus_trader.model import BarType
+from nautilus_trader.model import BookType
 from nautilus_trader.model import ClientOrderId
 from nautilus_trader.model import ContingencyType
 from nautilus_trader.model import InstrumentId
 from nautilus_trader.model import LimitOrder
 from nautilus_trader.model import MarketOrder
+from nautilus_trader.model import OrderBookDeltas
 from nautilus_trader.model import OrderFilled
 from nautilus_trader.model import OrderSide
 from nautilus_trader.model import Price
@@ -236,6 +238,97 @@ def on_stop(self):
         pass
 
 
+class OrderBookImbalanceConfig(StrategyConfig):
+    _CUSTOM_FIELDS = ("instrument_id", "trade_size")
+
+    def __new__(cls, *args, **kwargs):
+        for key in cls._CUSTOM_FIELDS:
+            kwargs.pop(key, None)
+        return super().__new__(cls, *args, **kwargs)
+
+    def __init__(
+        self,
+        instrument_id: str,
+        trade_size: str,
+        **kwargs,
+    ):
+        super().__init__()
+        self.instrument_id = instrument_id
+        self.trade_size = trade_size
+
+
+class OrderBookImbalance(Strategy):
+    _MIN_IMBALANCE_SIZE = Decimal(100)
+    _MAX_IMBALANCE_RATIO = Decimal("0.20")
+
+    def __init__(self, config: OrderBookImbalanceConfig):
+        super().__init__(config)
+        self._instrument_id = InstrumentId.from_str(config.instrument_id)
+        self._trade_size = Quantity.from_str(config.trade_size)
+        self._has_submitted = False
+
+    def on_start(self):
+        self.subscribe_book_deltas(self._instrument_id, BookType.L2_MBP)
+
+    def on_book_deltas(self, deltas: OrderBookDeltas):
+        if self._has_submitted:
+            return
+
+        bid_size = Decimal(0)
+        ask_size = Decimal(0)
+        bid_price = None
+        ask_price = None
+
+        for delta in deltas.deltas:
+            size = delta.order.size.as_decimal()
+            if delta.order.side == OrderSide.BUY:
+                bid_size += size
+                bid_price = delta.order.price
+            elif delta.order.side == OrderSide.SELL:
+                ask_size += size
+                ask_price = delta.order.price
+
+        if bid_size <= 0 or ask_size <= 0:
+            return
+
+        larger = max(bid_size, ask_size)
+        smaller = min(bid_size, ask_size)
+
+        if larger <= self._MIN_IMBALANCE_SIZE:
+            return
+
+        if smaller / larger >= self._MAX_IMBALANCE_RATIO:
+            return
+
+        if bid_size > ask_size and ask_price is not None:
+            side = OrderSide.BUY
+            price = ask_price
+        elif bid_price is not None:
+            side = OrderSide.SELL
+            price = bid_price
+        else:
+            return
+
+        self._has_submitted = True
+        self.submit_order(
+            self.order_factory.limit(
+                instrument_id=self._instrument_id,
+                order_side=side,
+                quantity=self._trade_size,
+                price=price,
+                time_in_force=TimeInForce.FOK,
+                post_only=False,
+            ),
+        )
+
+    def on_stop(self):
+        self.cancel_all_orders(self._instrument_id)
+        self.close_all_positions(self._instrument_id)
+
+    def on_reset(self):
+        self._has_submitted = False
+
+
 class MultiInstrumentTickScheduledConfig(StrategyConfig):
     """
     Submit market orders from an instrument keyed action schedule.