Qubx 0.6.21__tar.gz → 0.6.23__tar.gz

{qubx-0.6.21 → qubx-0.6.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: Qubx
-Version: 0.6.21
+Version: 0.6.23
 Summary: Qubx - Quantitative Trading Framework
 Author: Dmitry Marienko
 Author-email: dmitry.marienko@xlydian.com

{qubx-0.6.21 → qubx-0.6.23}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "Qubx"
-version = "0.6.21"
+version = "0.6.23"
 description = "Qubx - Quantitative Trading Framework"
 authors = [ "Dmitry Marienko <dmitry.marienko@xlydian.com>", "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",]
 readme = "README.md"

qubx-0.6.23/src/qubx/backtester/account.py

@@ -0,0 +1,83 @@
+from qubx.backtester.simulated_exchange import ISimulatedExchange
+from qubx.core.account import BasicAccountProcessor
+from qubx.core.basics import (
+    CtrlChannel,
+    Instrument,
+    Order,
+    Position,
+    Timestamped,
+    dt_64,
+)
+from qubx.core.series import OrderBook, Quote, Trade, TradeArray
+from qubx.restorers import RestoredState
+
+
+class SimulatedAccountProcessor(BasicAccountProcessor):
+    _channel: CtrlChannel
+    _exchange: ISimulatedExchange
+
+    def __init__(
+        self,
+        account_id: str,
+        exchange: ISimulatedExchange,
+        channel: CtrlChannel,
+        base_currency: str,
+        initial_capital: float,
+        restored_state: RestoredState | None = None,
+    ) -> None:
+        super().__init__(
+            account_id=account_id,
+            time_provider=exchange.get_time_provider(),
+            base_currency=base_currency,
+            tcc=exchange.get_transaction_costs_calculator(),
+            initial_capital=initial_capital,
+        )
+
+        self._exchange = exchange
+        self._channel = channel
+
+        if restored_state is not None:
+            self._balances.update(restored_state.balances)
+            for instrument, position in restored_state.positions.items():
+                _pos = self.get_position(instrument)
+                _pos.reset_by_position(position)
+
+    def get_orders(self, instrument: Instrument | None = None) -> dict[str, Order]:
+        return self._exchange.get_open_orders(instrument)
+
+    def get_position(self, instrument: Instrument) -> Position:
+        if instrument in self.positions:
+            return self.positions[instrument]
+
+        # - initialize empty position
+        position = Position(instrument)  # 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)
+
+        quote = (
+            update if isinstance(update, Quote) else self._exchange.emulate_quote_from_data(instrument, time, update)
+        )
+        if quote is None:
+            return
+
+        # - process new data
+        self._process_new_data(instrument, quote)
+
+    def process_market_data(self, time: dt_64, instrument: Instrument, update: Timestamped) -> None:
+        if isinstance(update, (TradeArray, Quote, Trade, OrderBook)):
+            # - process new data
+            self._process_new_data(instrument, update)
+
+        super().process_market_data(time, instrument, update)
+
+    def _process_new_data(self, instrument: Instrument, data: Quote | OrderBook | Trade | TradeArray) -> None:
+        for r in self._exchange.process_market_data(instrument, data):
+            if r.exec is not None:
+                # - 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-0.6.21 → qubx-0.6.23}/src/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-0.6.21 → qubx-0.6.23}/src/qubx/backtester/data.py

@@ -1,5 +1,5 @@
 from collections import defaultdict
-from typing import Any, Dict, Optional
+from typing import Any
 
 import numpy as np
 import pandas as pd
@@ -30,9 +30,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
@@ -143,7 +142,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 +150,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}")
 
@@ -266,7 +265,7 @@ class SimulatedDataProvider(IDataProvider):
                 cc.send((instrument, "event", {"order": sigs[0][1]}, False))
                 sigs.pop(0)
 
-            if q := self._account.emulate_quote_from_data(instrument, t, data):
+            if q := self._account._exchange.emulate_quote_from_data(instrument, t, data):
                 self._last_quotes[instrument] = q
 
         self.time_provider.set_time(t)
@@ -284,7 +283,7 @@ class SimulatedDataProvider(IDataProvider):
                 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):
+            if q := self._account._exchange.emulate_quote_from_data(instrument, t, data):
                 self._last_quotes[instrument] = q
 
         self.time_provider.set_time(t)

{qubx-0.6.21 → qubx-0.6.23}/src/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

{qubx-0.6.21 → qubx-0.6.23}/src/qubx/backtester/runner.py

@@ -17,6 +17,7 @@ from qubx.pandaz.utils import _frame_to_str
 from .account import SimulatedAccountProcessor
 from .broker import SimulatedBroker
 from .data import SimulatedDataProvider
+from .simulated_exchange import get_simulated_exchange
 from .utils import (
     SetupTypes,
     SignalsProxy,
@@ -176,17 +177,25 @@ class SimulationRunner:
             f"[<y>simulator</y>] :: Preparing simulated trading on <g>{self.setup.exchange.upper()}</g> for {self.setup.capital} {self.setup.base_currency}..."
         )
 
+        # - create simulated exchange:
+        #   - we can use different emulations of real exchanges features in future here: for Binance, Bybit, InteractiveBrokers, etc.
+        #   - for now we use simple basic simulated exchange implementation
+        simulated_exchange = get_simulated_exchange(
+            self.setup.exchange, simulated_clock, tcc, self.setup.accurate_stop_orders_execution
+        )
+
         account = SimulatedAccountProcessor(
             account_id=self.account_id,
+            exchange=simulated_exchange,
             channel=channel,
             base_currency=self.setup.base_currency,
             initial_capital=self.setup.capital,
-            time_provider=simulated_clock,
-            tcc=tcc,
-            accurate_stop_orders_execution=self.setup.accurate_stop_orders_execution,
         )
         scheduler = SimulatedScheduler(channel, lambda: simulated_clock.time().item())
-        broker = SimulatedBroker(channel, account, self.setup.exchange)
+
+        # - broker is order's interface to the exchange
+        broker = SimulatedBroker(channel, account, simulated_exchange)
+
         data_provider = SimulatedDataProvider(
             exchange_id=self.setup.exchange,
             channel=channel,
@@ -196,8 +205,10 @@ class SimulationRunner:
             readers=self.data_config.data_providers,
             open_close_time_indent_secs=self.data_config.adjusted_open_close_time_indent_secs,
         )
+
         # - get aux data provider
         _aux_data = self.data_config.get_timeguarded_aux_reader(simulated_clock)
+
         # - it will store simulation results into memory
         logs_writer = InMemoryLogsWriter(self.account_id, self.setup.name, "0")
 

qubx-0.6.23/src/qubx/backtester/simulated_exchange.py

@@ -0,0 +1,233 @@
+from collections.abc import Generator
+
+from qubx import logger
+from qubx.backtester.ome import OrdersManagementEngine, SimulatedExecutionReport
+from qubx.core.basics import (
+    ZERO_COSTS,
+    Instrument,
+    ITimeProvider,
+    Order,
+    Timestamped,
+    TransactionCostsCalculator,
+    dt_64,
+)
+from qubx.core.series import Bar, OrderBook, Quote, Trade, TradeArray
+
+
+class ISimulatedExchange:
+    """
+    Generic interface for simulated exchange.
+    """
+
+    exchange_id: str
+    _half_tick_size: dict[Instrument, float]
+
+    def __init__(self, exchange_id: str):
+        self.exchange_id = exchange_id.upper()
+        self._half_tick_size = {}
+
+    def get_time_provider(self) -> ITimeProvider: ...
+
+    def get_transaction_costs_calculator(self) -> TransactionCostsCalculator: ...
+
+    def place_order(
+        self,
+        instrument: Instrument,
+        order_side: str,
+        order_type: str,
+        amount: float,
+        price: float | None = None,
+        client_id: str | None = None,
+        time_in_force: str = "gtc",
+        **options,
+    ) -> SimulatedExecutionReport: ...
+
+    def cancel_order(self, order_id: str) -> SimulatedExecutionReport | None: ...
+
+    def get_open_orders(self, instrument: Instrument | None = None) -> dict[str, Order]: ...
+
+    def process_market_data(
+        self, instrument: Instrument, data: Quote | OrderBook | Trade | TradeArray
+    ) -> Generator[SimulatedExecutionReport]: ...
+
+    def emulate_quote_from_data(
+        self, instrument: Instrument, timestamp: dt_64, data: float | Timestamped
+    ) -> Quote | None:
+        """
+        Emulate quote from data.
+
+        TODO: we need to get rid of this method in the future
+        """
+        if instrument not in self._half_tick_size:
+            self._half_tick_size[instrument] = instrument.tick_size / 2  # type: ignore
+
+        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
+
+
+class BasicSimulatedExchange(ISimulatedExchange):
+    """
+    Basic implementation of generic crypto exchange.
+    """
+
+    _ome: dict[Instrument, OrdersManagementEngine]
+    _order_to_instrument: dict[str, Instrument]
+    _fill_stop_order_at_price: bool
+    _time_provider: ITimeProvider
+    _tcc: TransactionCostsCalculator
+
+    def __init__(
+        self,
+        exchange_id: str,
+        time_provider: ITimeProvider,
+        tcc: TransactionCostsCalculator = ZERO_COSTS,
+        accurate_stop_orders_execution: bool = False,
+    ):
+        super().__init__(exchange_id)
+        self._ome = {}
+        self._order_to_instrument = {}
+        self._half_tick_size = {}
+        self._fill_stop_order_at_price = accurate_stop_orders_execution
+        self._time_provider = time_provider
+        self._tcc = tcc
+        if self._fill_stop_order_at_price:
+            logger.info(
+                f"[<y>{self.__class__.__name__}</y>] :: emulation of stop orders executions at exact price is ON"
+            )
+
+    def get_time_provider(self) -> ITimeProvider:
+        return self._time_provider
+
+    def get_transaction_costs_calculator(self) -> TransactionCostsCalculator:
+        return self._tcc
+
+    def place_order(
+        self,
+        instrument: Instrument,
+        order_side: str,
+        order_type: str,
+        amount: float,
+        price: float | None = None,
+        client_id: str | None = None,
+        time_in_force: str = "gtc",
+        **options,
+    ) -> SimulatedExecutionReport:
+        # - try to place order in OME
+        return self._get_ome(instrument).place_order(
+            order_side.upper(),  # type: ignore
+            order_type.upper(),  # type: ignore
+            amount,
+            price,
+            client_id,
+            time_in_force,
+            **options,
+        )
+
+    def cancel_order(self, order_id: str) -> SimulatedExecutionReport | None:
+        # - first check in active orders
+        instrument = self._order_to_instrument.get(order_id)
+
+        if instrument is None:
+            # - if not found in active orders, check in each OME
+            for o in self._ome.values():
+                for order in o.get_open_orders():
+                    if order.id == order_id:
+                        return self._process_ome_response(o.cancel_order(order_id))
+
+            logger.error(
+                f"[<y>{self.__class__.__name__}</y>] :: cancel_order :: can't find order with id = 'ValueError{order_id}'!"
+            )
+            return None
+
+        ome = self._ome.get(instrument)
+        if ome is None:
+            raise ValueError(
+                f"{self.__class__.__name__}</y>] :: cancel_order :: No OME created for '{instrument}' - fatal error!"
+            )
+
+        # - cancel order in OME and remove from the map to free memory
+        return self._process_ome_response(ome.cancel_order(order_id))
+
+    def _process_ome_response(self, report: SimulatedExecutionReport | None) -> SimulatedExecutionReport | None:
+        if report is not None:
+            _order = report.order
+            _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 report
+
+    def get_open_orders(self, instrument: Instrument | None = None) -> dict[str, Order]:
+        if instrument is not None:
+            ome = self._get_ome(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()}
+
+    def _get_ome(self, instrument: Instrument) -> OrdersManagementEngine:
+        if (ome := self._ome.get(instrument)) is None:
+            self._half_tick_size[instrument] = instrument.tick_size / 2  # type: ignore
+            # - create order management engine for instrument
+            self._ome[instrument] = (
+                ome := OrdersManagementEngine(
+                    instrument=instrument,
+                    time_provider=self._time_provider,
+                    tcc=self._tcc,  # type: ignore
+                    fill_stop_order_at_price=self._fill_stop_order_at_price,
+                )
+            )
+        return ome
+
+    def process_market_data(
+        self, instrument: Instrument, data: Quote | OrderBook | Trade | TradeArray
+    ) -> Generator[SimulatedExecutionReport]:
+        ome = self._get_ome(instrument)
+
+        for r in ome.process_market_data(data):
+            if r.exec is not None:
+                if r.order.id in self._order_to_instrument:
+                    self._order_to_instrument.pop(r.order.id)
+                yield r
+
+
+def get_simulated_exchange(
+    exchange_name: str,
+    time_provider: ITimeProvider,
+    tcc: TransactionCostsCalculator,
+    accurate_stop_orders_execution=False,
+) -> ISimulatedExchange:
+    """
+    Factory function to create different types of simulated exchanges based on it's name etc
+    Now it supports only basic exchange that fits for most cases of crypto trading.
+    """
+    return BasicSimulatedExchange(
+        exchange_name, time_provider, tcc, accurate_stop_orders_execution=accurate_stop_orders_execution
+    )

{qubx-0.6.21 → qubx-0.6.23}/src/qubx/core/context.py

@@ -550,6 +550,7 @@ class StrategyContext(IStrategyContext):
                 if self._lifecycle_notifier:
                     self._lifecycle_notifier.notify_error(self._strategy_name, e)
                 # Don't stop the channel here, let it continue processing
+
         logger.info("[StrategyContext] :: Market data processing stopped")
 
     def __instantiate_strategy(self, strategy: IStrategy, config: dict[str, Any] | None) -> IStrategy: