Qubx 0.6.21__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.24__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/account.py

@@ -1,54 +1,40 @@
-from qubx import logger
-from qubx.backtester.ome import OrdersManagementEngine
+from qubx.backtester.simulated_exchange import ISimulatedExchange
 from qubx.core.account import BasicAccountProcessor
 from qubx.core.basics import (
-    ZERO_COSTS,
     CtrlChannel,
     Instrument,
     Order,
     Position,
     Timestamped,
-    TransactionCostsCalculator,
     dt_64,
 )
-from qubx.core.interfaces import ITimeProvider
-from qubx.core.series import Bar, OrderBook, Quote, Trade, TradeArray
+from qubx.core.series import OrderBook, Quote, Trade, TradeArray
 from qubx.restorers import RestoredState
 
 
 class SimulatedAccountProcessor(BasicAccountProcessor):
-    ome: dict[Instrument, OrdersManagementEngine]
-    order_to_instrument: dict[str, Instrument]
-
     _channel: CtrlChannel
-    _fill_stop_order_at_price: bool
-    _half_tick_size: dict[Instrument, float]
+    _exchange: ISimulatedExchange
 
     def __init__(
         self,
         account_id: str,
+        exchange: ISimulatedExchange,
         channel: CtrlChannel,
         base_currency: str,
         initial_capital: float,
-        time_provider: ITimeProvider,
-        tcc: TransactionCostsCalculator = ZERO_COSTS,
-        accurate_stop_orders_execution: bool = False,
         restored_state: RestoredState | None = None,
     ) -> None:
         super().__init__(
             account_id=account_id,
-            time_provider=time_provider,
+            time_provider=exchange.get_time_provider(),
             base_currency=base_currency,
-            tcc=tcc,
+            tcc=exchange.get_transaction_costs_calculator(),
             initial_capital=initial_capital,
         )
-        self.ome = {}
-        self.order_to_instrument = {}
+
+        self._exchange = exchange
         self._channel = channel
-        self._half_tick_size = {}
-        self._fill_stop_order_at_price = accurate_stop_orders_execution
-        if self._fill_stop_order_at_price:
-            logger.info(f"[<y>{self.__class__.__name__}</y>] :: emulates stop orders executions at exact price")
 
         if restored_state is not None:
             self._balances.update(restored_state.balances)
@@ -57,42 +43,25 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
                 _pos.reset_by_position(position)
 
     def get_orders(self, instrument: Instrument | None = None) -> dict[str, Order]:
-        if instrument is not None:
-            ome = self.ome.get(instrument)
-            if ome is None:
-                raise ValueError(f"ExchangeService:get_orders :: No OME configured for '{instrument}'!")
-
-            return {o.id: o for o in ome.get_open_orders()}
-
-        return {o.id: o for ome in self.ome.values() for o in ome.get_open_orders()}
+        return self._exchange.get_open_orders(instrument)
 
     def get_position(self, instrument: Instrument) -> Position:
         if instrument in self.positions:
             return self.positions[instrument]
 
-        # - initiolize OME for this instrument
-        self.ome[instrument] = OrdersManagementEngine(
-            instrument=instrument,
-            time_provider=self.time_provider,
-            tcc=self._tcc,  # type: ignore
-            fill_stop_order_at_price=self._fill_stop_order_at_price,
-        )
-
-        # - initiolize empty position
+        # - initialize empty position
         position = Position(instrument)  # type: ignore
-        self._half_tick_size[instrument] = instrument.tick_size / 2  # type: ignore
         self.attach_positions(position)
         return self.positions[instrument]
 
     def update_position_price(self, time: dt_64, instrument: Instrument, update: float | Timestamped) -> None:
+        self.get_position(instrument)
+
         super().update_position_price(time, instrument, update)
 
-        # - first we need to update OME with new quote.
-        # - if update is not a quote we need 'emulate' it.
-        # - actually if SimulatedExchangeService is used in backtesting mode it will recieve only quotes
-        # - case when we need that - SimulatedExchangeService is used for paper trading and data provider configured to listen to OHLC or TAS.
-        # - probably we need to subscribe to quotes in real data provider in any case and then this emulation won't be needed.
-        quote = update if isinstance(update, Quote) else self.emulate_quote_from_data(instrument, time, update)
+        quote = (
+            update if isinstance(update, Quote) else self._exchange.emulate_quote_from_data(instrument, time, update)
+        )
         if quote is None:
             return
 
@@ -106,56 +75,9 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
 
         super().process_market_data(time, instrument, update)
 
-    def process_order(self, order: Order, update_locked_value: bool = True) -> None:
-        _new = order.status == "NEW"
-        _open = order.status == "OPEN"
-        _cancel = order.status == "CANCELED"
-        _closed = order.status == "CLOSED"
-        if _new or _open:
-            self.order_to_instrument[order.id] = order.instrument
-        if (_cancel or _closed) and order.id in self.order_to_instrument:
-            self.order_to_instrument.pop(order.id)
-        return super().process_order(order, update_locked_value)
-
-    def emulate_quote_from_data(
-        self, instrument: Instrument, timestamp: dt_64, data: float | Timestamped
-    ) -> Quote | None:
-        if instrument not in self._half_tick_size:
-            _ = self.get_position(instrument)
-
-        if isinstance(data, Quote):
-            return data
-
-        elif isinstance(data, Trade):
-            _ts2 = self._half_tick_size[instrument]
-            if data.side == 1:  # type: ignore
-                return Quote(timestamp, data.price - _ts2 * 2, data.price, 0, 0)  # type: ignore
-            else:
-                return Quote(timestamp, data.price, data.price + _ts2 * 2, 0, 0)  # type: ignore
-
-        elif isinstance(data, Bar):
-            _ts2 = self._half_tick_size[instrument]
-            return Quote(timestamp, data.close - _ts2, data.close + _ts2, 0, 0)  # type: ignore
-
-        elif isinstance(data, OrderBook):
-            return data.to_quote()
-
-        elif isinstance(data, float):
-            _ts2 = self._half_tick_size[instrument]
-            return Quote(timestamp, data - _ts2, data + _ts2, 0, 0)
-
-        else:
-            return None
-
     def _process_new_data(self, instrument: Instrument, data: Quote | OrderBook | Trade | TradeArray) -> None:
-        ome = self.ome.get(instrument)
-        if ome is None:
-            logger.warning(f"ExchangeService:update :: No OME configured for '{instrument}' yet !")
-            return
-        for r in ome.process_market_data(data):
+        for r in self._exchange.process_market_data(instrument, data):
             if r.exec is not None:
-                if r.order.id in self.order_to_instrument:
-                    self.order_to_instrument.pop(r.order.id)
                 # - process methods will be called from stg context
                 self._channel.send((instrument, "order", r.order, False))
                 self._channel.send((instrument, "deals", [r.exec], False))

qubx/backtester/broker.py

@@ -1,4 +1,5 @@
-from qubx.backtester.ome import OmeReport
+from qubx.backtester.ome import SimulatedExecutionReport
+from qubx.backtester.simulated_exchange import ISimulatedExchange
 from qubx.core.basics import (
     CtrlChannel,
     Instrument,
@@ -13,16 +14,17 @@ class SimulatedBroker(IBroker):
     channel: CtrlChannel
 
     _account: SimulatedAccountProcessor
+    _exchange: ISimulatedExchange
 
     def __init__(
         self,
         channel: CtrlChannel,
         account: SimulatedAccountProcessor,
-        exchange_id: str = "simulated",
+        simulated_exchange: ISimulatedExchange,
     ) -> None:
         self.channel = channel
         self._account = account
-        self._exchange_id = exchange_id
+        self._exchange = simulated_exchange
 
     @property
     def is_simulated_trading(self) -> bool:
@@ -39,22 +41,12 @@ class SimulatedBroker(IBroker):
         time_in_force: str = "gtc",
         **options,
     ) -> Order:
-        ome = self._account.ome.get(instrument)
-        if ome is None:
-            raise ValueError(f"ExchangeService:send_order :: No OME configured for '{instrument.symbol}'!")
-
-        # - try to place order in OME
-        report = ome.place_order(
-            order_side.upper(),  # type: ignore
-            order_type.upper(),  # type: ignore
-            amount,
-            price,
-            client_id,
-            time_in_force,
-            **options,
+        # - place order at exchange and send exec report to data channel
+        self._send_execution_report(
+            report := self._exchange.place_order(
+                instrument, order_side, order_type, amount, price, client_id, time_in_force, **options
+            )
         )
-
-        self._send_exec_report(instrument, report)
         return report.order
 
     def send_order_async(
@@ -71,22 +63,8 @@ class SimulatedBroker(IBroker):
         self.send_order(instrument, order_side, order_type, amount, price, client_id, time_in_force, **optional)
 
     def cancel_order(self, order_id: str) -> Order | None:
-        instrument = self._account.order_to_instrument.get(order_id)
-        if instrument is None:
-            raise ValueError(f"ExchangeService:cancel_order :: can't find order with id = '{order_id}'!")
-
-        ome = self._account.ome.get(instrument)
-        if ome is None:
-            raise ValueError(f"ExchangeService:send_order :: No OME configured for '{instrument}'!")
-
-        # - cancel order in OME and remove from the map to free memory
-        order_update = ome.cancel_order(order_id)
-        if order_update is None:
-            return None
-
-        self._send_exec_report(instrument, order_update)
-
-        return order_update.order
+        self._send_execution_report(order_update := self._exchange.cancel_order(order_id))
+        return order_update.order if order_update is not None else None
 
     def cancel_orders(self, instrument: Instrument) -> None:
         raise NotImplementedError("Not implemented yet")
@@ -94,10 +72,13 @@ class SimulatedBroker(IBroker):
     def update_order(self, order_id: str, price: float | None = None, amount: float | None = None) -> Order:
         raise NotImplementedError("Not implemented yet")
 
-    def _send_exec_report(self, instrument: Instrument, report: OmeReport):
-        self.channel.send((instrument, "order", report.order, False))
+    def _send_execution_report(self, report: SimulatedExecutionReport | None):
+        if report is None:
+            return
+
+        self.channel.send((report.instrument, "order", report.order, False))
         if report.exec is not None:
-            self.channel.send((instrument, "deals", [report.exec], False))
+            self.channel.send((report.instrument, "deals", [report.exec], False))
 
     def exchange(self) -> str:
-        return self._exchange_id.upper()
+        return self._exchange.exchange_id

qubx/backtester/data.py

@@ -1,9 +1,6 @@
 from collections import defaultdict
-from typing import Any, Dict, Optional
 
-import numpy as np
 import pandas as pd
-from tqdm.auto import tqdm
 
 from qubx import logger
 from qubx.backtester.simulated_data import IterableSimulationData
@@ -13,7 +10,6 @@ from qubx.core.basics import (
     Instrument,
     TimestampedDict,
 )
-from qubx.core.exceptions import SimulationError
 from qubx.core.helpers import BasicScheduler
 from qubx.core.interfaces import IDataProvider
 from qubx.core.series import Bar, Quote, time_as_nsec
@@ -30,11 +26,8 @@ class SimulatedDataProvider(IDataProvider):
 
     _scheduler: BasicScheduler
     _account: SimulatedAccountProcessor
-    _last_quotes: Dict[Instrument, Optional[Quote]]
+    _last_quotes: dict[Instrument, Quote | None]
     _readers: dict[str, DataReader]
-    _scheduler: BasicScheduler
-    _pregenerated_signals: dict[Instrument, pd.Series | pd.DataFrame]
-    _to_process: dict[Instrument, list]
     _data_source: IterableSimulationData
     _open_close_time_indent_ns: int
 
@@ -46,6 +39,7 @@ class SimulatedDataProvider(IDataProvider):
         time_provider: SimulatedTimeProvider,
         account: SimulatedAccountProcessor,
         readers: dict[str, DataReader],
+        data_source: IterableSimulationData,
         open_close_time_indent_secs=1,
     ):
         self.channel = channel
@@ -55,79 +49,14 @@ class SimulatedDataProvider(IDataProvider):
         self._account = account
         self._readers = readers
 
-        # - create exchange's instance
-        self._last_quotes = defaultdict(lambda: None)
-
-        # - pregenerated signals storage
-        self._pregenerated_signals = dict()
-        self._to_process = {}
-
         # - simulation data source
-        self._data_source = IterableSimulationData(
-            self._readers, open_close_time_indent_secs=open_close_time_indent_secs
-        )
+        self._data_source = data_source
         self._open_close_time_indent_ns = open_close_time_indent_secs * 1_000_000_000  # convert seconds to nanoseconds
 
-        logger.info(f"{self.__class__.__name__}.{exchange_id} is initialized")
-
-    def run(
-        self,
-        start: str | pd.Timestamp,
-        end: str | pd.Timestamp,
-        silent: bool = False,
-    ) -> None:
-        logger.info(f"{self.__class__.__name__} ::: Simulation started at {start} :::")
-
-        if self._pregenerated_signals:
-            self._prepare_generated_signals(start, end)
-            _run = self._process_generated_signals
-        else:
-            _run = self._process_strategy
-
-        start, end = pd.Timestamp(start), pd.Timestamp(end)
-        total_duration = end - start
-        update_delta = total_duration / 100
-        prev_dt = pd.Timestamp(start)
-
-        # - date iteration
-        qiter = self._data_source.create_iterable(start, end)
-        if silent:
-            for instrument, data_type, event, is_hist in qiter:
-                if not _run(instrument, data_type, event, is_hist):
-                    break
-        else:
-            _p = 0
-            with tqdm(total=100, desc="Simulating", unit="%", leave=False) as pbar:
-                for instrument, data_type, event, is_hist in qiter:
-                    if not _run(instrument, data_type, event, is_hist):
-                        break
-                    dt = pd.Timestamp(event.time)
-                    # update only if date has changed
-                    if dt - prev_dt > update_delta:
-                        _p += 1
-                        pbar.n = _p
-                        pbar.refresh()
-                        prev_dt = dt
-                pbar.n = 100
-                pbar.refresh()
-
-        logger.info(f"{self.__class__.__name__} ::: Simulation finished at {end} :::")
-
-    def set_generated_signals(self, signals: pd.Series | pd.DataFrame):
-        logger.debug(
-            f"[<y>{self.__class__.__name__}</y>] :: Using pre-generated signals:\n {str(signals.count()).strip('ndtype: int64')}"
-        )
-        # - sanity check
-        signals.index = pd.DatetimeIndex(signals.index)
-
-        if isinstance(signals, pd.Series):
-            self._pregenerated_signals[str(signals.name)] = signals  # type: ignore
+        # - create exchange's instance
+        self._last_quotes = defaultdict(lambda: None)
 
-        elif isinstance(signals, pd.DataFrame):
-            for col in signals.columns:
-                self._pregenerated_signals[col] = signals[col]  # type: ignore
-        else:
-            raise ValueError("Invalid signals or strategy configuration")
+        logger.info(f"{self.__class__.__name__}.{exchange_id} is initialized")
 
     @property
     def is_simulation(self) -> bool:
@@ -143,7 +72,7 @@ class SimulatedDataProvider(IDataProvider):
             if h_data:
                 # _s_type = DataType.from_str(subscription_type)[0]
                 last_update = h_data[-1]
-                if last_quote := self._account.emulate_quote_from_data(i, last_update.time, last_update):  # type: ignore
+                if last_quote := self._account._exchange.emulate_quote_from_data(i, last_update.time, last_update):  # type: ignore
                     # - send historical data to the channel
                     self.channel.send((i, subscription_type, h_data, True))
 
@@ -151,7 +80,7 @@ class SimulatedDataProvider(IDataProvider):
                     self._last_quotes[i] = last_quote
 
                     # - also need to pass this quote to OME !
-                    self._account._process_new_data(i, last_quote)
+                    self._account.process_market_data(last_quote.time, i, last_quote)  # type: ignore
 
                     logger.debug(f" | subscribed {subscription_type} {i} -> {last_quote}")
 
@@ -201,26 +130,6 @@ class SimulatedDataProvider(IDataProvider):
     def close(self):
         pass
 
-    def _prepare_generated_signals(self, start: str | pd.Timestamp, end: str | pd.Timestamp):
-        for s, v in self._pregenerated_signals.items():
-            _s_inst = None
-
-            for i in self.get_subscribed_instruments():
-                # - we can process series with variable id's if we can find some similar instrument
-                if s == i.symbol or s == str(i) or s == f"{i.exchange}:{i.symbol}" or str(s) == str(i):
-                    _start, _end = pd.Timestamp(start), pd.Timestamp(end)
-                    _start_idx, _end_idx = v.index.get_indexer([_start, _end], method="ffill")
-                    sel = v.iloc[max(_start_idx, 0) : _end_idx + 1]
-
-                    # TODO: check if data has exec_price - it means we have deals
-                    self._to_process[i] = list(zip(sel.index, sel.values))
-                    _s_inst = i
-                    break
-
-            if _s_inst is None:
-                logger.error(f"Can't find instrument for pregenerated signals with id '{s}'")
-                raise SimulationError(f"Can't find instrument for pregenerated signals with id '{s}'")
-
     def _convert_records_to_bars(
         self, records: list[TimestampedDict], cut_time_ns: int, timeframe_ns: int
     ) -> list[Bar]:
@@ -253,44 +162,5 @@ class SimulatedDataProvider(IDataProvider):
 
         return bars
 
-    def _process_generated_signals(self, instrument: Instrument, data_type: str, data: Any, is_hist: bool) -> bool:
-        cc = self.channel
-        t = np.datetime64(data.time, "ns")
-
-        if not is_hist:
-            # - signals for this instrument
-            sigs = self._to_process[instrument]
-
-            while sigs and t >= (_signal_time := sigs[0][0].as_unit("ns").asm8):
-                self.time_provider.set_time(_signal_time)
-                cc.send((instrument, "event", {"order": sigs[0][1]}, False))
-                sigs.pop(0)
-
-            if q := self._account.emulate_quote_from_data(instrument, t, data):
-                self._last_quotes[instrument] = q
-
-        self.time_provider.set_time(t)
-        cc.send((instrument, data_type, data, is_hist))
-
-        return cc.control.is_set()
-
-    def _process_strategy(self, instrument: Instrument, data_type: str, data: Any, is_hist: bool) -> bool:
-        cc = self.channel
-        t = np.datetime64(data.time, "ns")
-
-        if not is_hist:
-            if t >= (_next_exp_time := self._scheduler.next_expected_event_time()):
-                # - we use exact event's time
-                self.time_provider.set_time(_next_exp_time)
-                self._scheduler.check_and_run_tasks()
-
-            if q := self._account.emulate_quote_from_data(instrument, t, data):
-                self._last_quotes[instrument] = q
-
-        self.time_provider.set_time(t)
-        cc.send((instrument, data_type, data, is_hist))
-
-        return cc.control.is_set()
-
     def exchange(self) -> str:
         return self._exchange_id.upper()

qubx/backtester/ome.py

@@ -27,7 +27,8 @@ from qubx.core.series import OrderBook, Quote, Trade, TradeArray
 
 
 @dataclass
-class OmeReport:
+class SimulatedExecutionReport:
+    instrument: Instrument
     timestamp: dt_64
     order: Order
     exec: Deal | None
@@ -91,7 +92,7 @@ class OrdersManagementEngine:
     def get_open_orders(self) -> list[Order]:
         return list(self.active_orders.values()) + list(self.stop_orders.values())
 
-    def process_market_data(self, mdata: Quote | OrderBook | Trade | TradeArray) -> list[OmeReport]:
+    def process_market_data(self, mdata: Quote | OrderBook | Trade | TradeArray) -> list[SimulatedExecutionReport]:
         """
         Processes the new market data (quote, trade or trades array) and simulates the execution of pending orders.
         """
@@ -173,7 +174,7 @@ class OrdersManagementEngine:
         client_id: str | None = None,
         time_in_force: str = "gtc",
         **options,
-    ) -> OmeReport:
+    ) -> SimulatedExecutionReport:
         if self.bbo is None:
             raise ExchangeError(f"Simulator is not ready for order management - no quote for {self.instrument.symbol}")
 
@@ -200,7 +201,7 @@ class OrdersManagementEngine:
     def _dbg(self, message, **kwargs) -> None:
         logger.debug(f"    [<y>OME</y>(<g>{self.instrument}</g>)] :: {message}", **kwargs)
 
-    def _process_order(self, timestamp: dt_64, order: Order) -> OmeReport:
+    def _process_order(self, timestamp: dt_64, order: Order) -> SimulatedExecutionReport:
         if order.status in ["CLOSED", "CANCELED"]:
             raise InvalidOrder(f"Order {order.id} is already closed or canceled.")
 
@@ -273,12 +274,15 @@ class OrdersManagementEngine:
             self.active_orders[order.id] = order
 
         self._dbg(f"registered {order.id} {order.type} {order.side} {order.quantity} {order.price}")
-        return OmeReport(timestamp, order, None)
+        return SimulatedExecutionReport(self.instrument, timestamp, order, None)
 
-    def _execute_order(self, timestamp: dt_64, exec_price: float, order: Order, taker: bool) -> OmeReport:
+    def _execute_order(
+        self, timestamp: dt_64, exec_price: float, order: Order, taker: bool
+    ) -> SimulatedExecutionReport:
         order.status = "CLOSED"
         self._dbg(f"<red>{order.id}</red> {order.type} {order.side} {order.quantity} executed at {exec_price}")
-        return OmeReport(
+        return SimulatedExecutionReport(
+            self.instrument,
             timestamp,
             order,
             Deal(
@@ -322,7 +326,7 @@ class OrdersManagementEngine:
                     f"Stop price would trigger immediately: STOP_MARKET {order_side} {amount} of {self.instrument.symbol} at {price} | market: {c_ask} / {c_bid}"
                 )
 
-    def cancel_order(self, order_id: str) -> OmeReport | None:
+    def cancel_order(self, order_id: str) -> SimulatedExecutionReport | None:
         # - check limit orders
         if order_id in self.active_orders:
             order = self.active_orders.pop(order_id)
@@ -346,7 +350,7 @@ class OrdersManagementEngine:
 
         order.status = "CANCELED"
         self._dbg(f"{order.id} {order.type} {order.side} {order.quantity} canceled")
-        return OmeReport(self.time_service.time(), order, None)
+        return SimulatedExecutionReport(self.instrument, self.time_service.time(), order, None)
 
     def __str__(self) -> str:
         _a, _b = True, True