Qubx 0.6.21__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.23__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,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/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/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/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/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:

qubx/core/interfaces.py

@@ -14,7 +14,7 @@ This module includes:
 
 import traceback
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Literal, Protocol, Set, Tuple
+from typing import Any, Callable, Literal, Protocol
 
 import numpy as np
 import pandas as pd
@@ -49,24 +49,24 @@ RemovalPolicy = Literal["close", "wait_for_close", "wait_for_change"]
 class ITradeDataExport:
     """Interface for exporting trading data to external systems."""
 
-    def export_signals(self, time: dt_64, signals: List[Signal], account: "IAccountViewer") -> None:
+    def export_signals(self, time: dt_64, signals: list[Signal], account: "IAccountViewer") -> None:
         """
         Export signals to an external system.
 
         Args:
             time: Timestamp when the signals were generated
-            signals: List of signals to export
+            signals: list of signals to export
             account: Account viewer to get account information like total capital, leverage, etc.
         """
         pass
 
-    def export_target_positions(self, time: dt_64, targets: List[TargetPosition], account: "IAccountViewer") -> None:
+    def export_target_positions(self, time: dt_64, targets: list[TargetPosition], account: "IAccountViewer") -> None:
         """
         Export target positions to an external system.
 
         Args:
             time: Timestamp when the target positions were generated
-            targets: List of target positions to export
+            targets: list of target positions to export
             account: Account viewer to get account information like total capital, leverage, etc.
         """
         pass
@@ -377,7 +377,7 @@ class IDataProvider:
     def subscribe(
         self,
         subscription_type: str,
-        instruments: Set[Instrument],
+        instruments: set[Instrument],
         reset: bool = False,
     ) -> None:
         """
@@ -390,7 +390,7 @@ class IDataProvider:
         """
         ...
 
-    def unsubscribe(self, subscription_type: str | None, instruments: Set[Instrument]) -> None:
+    def unsubscribe(self, subscription_type: str | None, instruments: set[Instrument]) -> None:
         """
         Unsubscribe from market data for a list of instruments.
 
@@ -413,7 +413,7 @@ class IDataProvider:
         """
         ...
 
-    def get_subscriptions(self, instrument: Instrument | None = None) -> List[str]:
+    def get_subscriptions(self, instrument: Instrument | None = None) -> list[str]:
         """
         Get all subscriptions for an instrument.
 
@@ -421,11 +421,11 @@ class IDataProvider:
             instrument (optional): Instrument to get subscriptions for. If None, all subscriptions are returned.
 
         Returns:
-            List[str]: List of subscriptions
+            list[str]: list of subscriptions
         """
         ...
 
-    def get_subscribed_instruments(self, subscription_type: str | None = None) -> List[Instrument]:
+    def get_subscribed_instruments(self, subscription_type: str | None = None) -> list[Instrument]:
         """
         Get a list of instruments that are subscribed to a specific subscription type.
 
@@ -433,11 +433,11 @@ class IDataProvider:
             subscription_type: Type of subscription to filter by (optional)
 
         Returns:
-            List[Instrument]: List of subscribed instruments
+            list[Instrument]: list of subscribed instruments
         """
         ...
 
-    def warmup(self, configs: Dict[Tuple[str, Instrument], str]) -> None:
+    def warmup(self, configs: dict[tuple[str, Instrument], str]) -> None:
         """
         Run warmup for subscriptions.
 
@@ -522,7 +522,7 @@ class IMarketManager(ITimeProvider):
             sub_type: The subscription type of data to get
 
         Returns:
-            List[Any]: The data
+            list[Any]: The data
         """
         ...
 
@@ -542,7 +542,7 @@ class IMarketManager(ITimeProvider):
         """Get list of subscribed instruments.
 
         Returns:
-            list[Instrument]: List of subscribed instruments
+            list[Instrument]: list of subscribed instruments
         """
         ...
 
@@ -683,9 +683,9 @@ class IUniverseManager:
         """Set the trading universe.
 
         Args:
-            instruments: List of instruments in the universe
-            skip_callback: Skip callback to the strategy
-            if_has_position_then: What to do if the instrument has a position
+            instruments: list of instruments in the universe
+            skip_callback: skip callback to the strategy
+            if_has_position_then: what to do if the instrument has a position
                 - "close" (default) - close position immediatelly and remove (unsubscribe) instrument from strategy
                 - "wait_for_close" - keep instrument and it's position until it's closed from strategy (or risk management), then remove instrument from strategy
                 - "wait_for_change" - keep instrument and position until strategy would try to change it - then close position and remove instrument
@@ -752,7 +752,7 @@ class IUniverseManager:
 class ISubscriptionManager:
     """Manages subscriptions."""
 
-    def subscribe(self, subscription_type: str, instruments: List[Instrument] | Instrument | None = None) -> None:
+    def subscribe(self, subscription_type: str, instruments: list[Instrument] | Instrument | None = None) -> None:
         """Subscribe to market data for an instrument.
 
         Args:
@@ -761,7 +761,7 @@ class ISubscriptionManager:
         """
         ...
 
-    def unsubscribe(self, subscription_type: str, instruments: List[Instrument] | Instrument | None = None) -> None:
+    def unsubscribe(self, subscription_type: str, instruments: list[Instrument] | Instrument | None = None) -> None:
         """Unsubscribe from market data for an instrument.
 
         Args:
@@ -799,7 +799,7 @@ class ISubscriptionManager:
         """
         ...
 
-    def get_subscriptions(self, instrument: Instrument | None = None) -> List[str]:
+    def get_subscriptions(self, instrument: Instrument | None = None) -> list[str]:
         """
         Get all subscriptions for an instrument.
 
@@ -807,11 +807,11 @@ class ISubscriptionManager:
             instrument: Instrument to get subscriptions for (optional)
 
         Returns:
-            List[str]: List of subscriptions
+            list[str]: list of subscriptions
         """
         ...
 
-    def get_subscribed_instruments(self, subscription_type: str | None = None) -> List[Instrument]:
+    def get_subscribed_instruments(self, subscription_type: str | None = None) -> list[Instrument]:
         """
         Get a list of instruments that are subscribed to a specific subscription type.
 
@@ -819,7 +819,7 @@ class ISubscriptionManager:
             subscription_type: Type of subscription to filter by (optional)
 
         Returns:
-            List[Instrument]: List of subscribed instruments
+            list[Instrument]: list of subscribed instruments
         """
         ...
 
@@ -963,7 +963,7 @@ class IAccountProcessor(IAccountViewer):
         """
         ...
 
-    def add_active_orders(self, orders: Dict[str, Order]) -> None:
+    def add_active_orders(self, orders: dict[str, Order]) -> None:
         """Add active orders to the account.
 
         Warning only use in the beginning for state restoration because it does not update locked balances.
@@ -1116,8 +1116,8 @@ class IPositionGathering:
     def alter_position_size(self, ctx: IStrategyContext, target: TargetPosition) -> float: ...
 
     def alter_positions(
-        self, ctx: IStrategyContext, targets: List[TargetPosition] | TargetPosition
-    ) -> Dict[Instrument, float]:
+        self, ctx: IStrategyContext, targets: list[TargetPosition] | TargetPosition
+    ) -> dict[Instrument, float]:
         if not isinstance(targets, list):
             targets = [targets]
 
@@ -1195,7 +1195,7 @@ class PositionsTracker:
 
     def update(
         self, ctx: IStrategyContext, instrument: Instrument, update: Timestamped
-    ) -> List[TargetPosition] | TargetPosition:
+    ) -> list[TargetPosition] | TargetPosition:
         """
         Tracker is being updated by new market data.
         It may require to change position size or create new position because of interior tracker's logic (risk management for example).
@@ -1730,7 +1730,7 @@ class IStrategy(metaclass=Mixable):
         """
         return None
 
-    def on_event(self, ctx: IStrategyContext, event: TriggerEvent) -> List[Signal] | Signal | None:
+    def on_event(self, ctx: IStrategyContext, event: TriggerEvent) -> list[Signal] | Signal | None:
         """Called on strategy events.
 
         Args:
@@ -1742,7 +1742,7 @@ class IStrategy(metaclass=Mixable):
         """
         return None
 
-    def on_market_data(self, ctx: IStrategyContext, data: MarketEvent) -> List[Signal] | Signal | None:
+    def on_market_data(self, ctx: IStrategyContext, data: MarketEvent) -> list[Signal] | Signal | None:
         """
         Called when new market data is received.
 

qubx/ta/indicators.pxd

@@ -59,7 +59,7 @@ cdef class Lowest(Indicator):
 
 cdef class Std(Indicator):
     cdef int period
-    cdef RollingSum rolling_sum, variance_sum
+    cdef RollingSum rolling_sum, rolling_sum_sq
     cpdef double calculate(self, long long time, double value, short new_item_started)
 
 

qubx/ta/indicators.pyx

@@ -226,29 +226,26 @@ cdef class Std(Indicator):
     def __init__(self, str name, TimeSeries series, int period):
         self.period = period
         self.rolling_sum = RollingSum(period)
-        self.variance_sum = RollingSum(period)
+        self.rolling_sum_sq = RollingSum(period)
         super().__init__(name, series)
 
     cpdef double calculate(self, long long time, double value, short new_item_started):
         # Update the rolling sum with the new value
         cdef double _sum = self.rolling_sum.update(value, new_item_started)
+        cdef double _sum_sq = self.rolling_sum_sq.update(value * value, new_item_started)
 
         # If we're still in the initialization stage, return NaN
-        if self.rolling_sum.is_init_stage:
+        if self.rolling_sum.is_init_stage or self.rolling_sum_sq.is_init_stage:
             return np.nan
 
         # Calculate the mean from the rolling sum
         cdef double _mean = _sum / self.period
 
         # Update the variance sum with the squared deviation from the mean
-        cdef double _var_sum = self.variance_sum.update((value - _mean) ** 2, new_item_started)
-
-        # If the variance sum is still in the initialization stage, return NaN
-        if self.variance_sum.is_init_stage:
-            return np.nan
+        cdef double _variance = _sum_sq / self.period - _mean * _mean
 
         # Return the square root of the variance (standard deviation)
-        return np.sqrt(_var_sum / self.period)
+        return np.sqrt(_variance)
 
 
 def std(series: TimeSeries, period: int, mean=0):

qubx/utils/runner/runner.py

@@ -13,6 +13,7 @@ from qubx.backtester.account import SimulatedAccountProcessor
 from qubx.backtester.broker import SimulatedBroker
 from qubx.backtester.optimization import variate
 from qubx.backtester.runner import SimulationRunner
+from qubx.backtester.simulated_exchange import get_simulated_exchange
 from qubx.backtester.utils import (
     SetupTypes,
     SimulatedLogFormatter,
@@ -452,12 +453,15 @@ def _create_account_processor(
 ) -> IAccountProcessor:
     if paper:
         settings = account_manager.get_exchange_settings(exchange_name)
+
+        # - TODO: here we can create  different types of simulated exchanges based on it's name etc
+        simulated_exchange = get_simulated_exchange(exchange_name, time_provider, tcc)
+
         return SimulatedAccountProcessor(
             account_id=exchange_name,
+            exchange=simulated_exchange,
             channel=channel,
             base_currency=settings.base_currency,
-            time_provider=time_provider,
-            tcc=tcc,
             initial_capital=settings.initial_capital,
             restored_state=restored_state,
         )
@@ -493,7 +497,7 @@ def _create_broker(
 ) -> IBroker:
     if paper:
         assert isinstance(account, SimulatedAccountProcessor)
-        return SimulatedBroker(channel=channel, account=account, exchange_id=exchange_name)
+        return SimulatedBroker(channel=channel, account=account, simulated_exchange=account._exchange)
 
     creds = account_manager.get_exchange_credentials(exchange_name)
 

{qubx-0.6.21.dist-info → qubx-0.6.23.dist-info}/METADATA

@@ -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.dist-info → qubx-0.6.23.dist-info}/RECORD

@@ -1,14 +1,15 @@
 qubx/__init__.py,sha256=GBvbyDpm2yCMJVmGW66Jo0giLOUsKKldDGcVA_r9Ohc,8294
 qubx/_nb_magic.py,sha256=kcYn8qNb8O223ZRPpq30_n5e__lD5GSVcd0U_jhfnbM,3019
 qubx/backtester/__init__.py,sha256=OhXhLmj2x6sp6k16wm5IPATvv-E2qRZVIcvttxqPgcg,176
-qubx/backtester/account.py,sha256=BFbQYpdeQ81yMw2ghLr2TqWke6NWn1e_FFjHAGtiYkw,6672
-qubx/backtester/broker.py,sha256=yyS12b7e-7Vs_czRLXu_-pl7P47vN6tfEs6r3W0cba4,3221
-qubx/backtester/data.py,sha256=DEEtVlpiLNcvIDOMZcgmIkwvb-GSD2YP2qgxWxUyFxg,11966
+qubx/backtester/account.py,sha256=0yvE06icSeK2ymovvaKkuftY8Ou3Z7Y2JrDa6VtkINw,3048
+qubx/backtester/broker.py,sha256=JMasxycLqCT99NxN50uyQ1uxtpHYL0wpp4sJ3hB6v2M,2688
+qubx/backtester/data.py,sha256=vxpZCoFZsxI7QKDfragGlb0-tCplMJH99xVZWKcvEm0,11981
 qubx/backtester/management.py,sha256=HuyzFsBPgR7j-ei78Ngcx34CeSn65c9atmaii1aTsYg,14900
-qubx/backtester/ome.py,sha256=8AwOKxpL_sM2Tk9EUbfmrE5z9Lg-YnHSCtLxeSoCaFE,14745
+qubx/backtester/ome.py,sha256=hfqwvaMBccDpy6eMe04QupEA6BjfjAodbm707fbQUb0,14984
 qubx/backtester/optimization.py,sha256=HHUIYA6Y66rcOXoePWFOuOVX9iaHGKV0bGt_4d5e6FM,7619
-qubx/backtester/runner.py,sha256=WlGUP-b8RxYzBKgNJQIi0dQ379hV0lVp4rOZ60lKIDg,11092
+qubx/backtester/runner.py,sha256=VM0qiq27lccBDNjenYrjIJD3acMtTNfs3T9HJCBcnLk,11507
 qubx/backtester/simulated_data.py,sha256=niujaMRj__jf4IyzCZrSBR5ZoH1VUbvsZHSewHftdmI,17240
+qubx/backtester/simulated_exchange.py,sha256=ATGcJXnKdD47kUwgbc5tvPVL0tq4_-6jpgsTTAMxW3c,8124
 qubx/backtester/simulator.py,sha256=JkGm5xP8q0p4BuR_PEoDm66Uaqc0u-NX-vyjkia_0Vc,9410
 qubx/backtester/utils.py,sha256=6WKTlw6nArnZgGrJatDl8ExqvTHH0SyqEbDbMgiJbIk,33539
 qubx/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -30,13 +31,13 @@ qubx/connectors/ccxt/utils.py,sha256=oMvL0Zh-Tt9pKPTCcZMTo293mScvTiZlE9XKw2-qDgg
 qubx/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubx/core/account.py,sha256=b_tKnXQxpQCoJB-kVvrFzzTgDz2lLcebQdtP99x9N8I,10912
 qubx/core/basics.py,sha256=fynmFt6n8dc-9g9IuaXxixB8x52VQ1yFQDDK_FH3LmU,29463
-qubx/core/context.py,sha256=TgjJP0nMfVikKY7uIphcsG6xhxpS1NpSiNNkdU1ycmo,21874
+qubx/core/context.py,sha256=PmO0x5VWGXY6zMF7H2rrTgPwNhDhq-f5Y8diUoZmNE0,21875
 qubx/core/deque.py,sha256=3PsmJ5LF76JpsK4Wp5LLogyE15rKn6EDCkNOOWT6EOk,6203
 qubx/core/errors.py,sha256=kWCK6o0-mm87VUhhlGKqwTpvdDXAza7YRRjeyz-vwfI,609
 qubx/core/exceptions.py,sha256=11wQC3nnNLsl80zBqbE6xiKCqm31kctqo6W_gdnZkg8,581
 qubx/core/helpers.py,sha256=9nl9L_ZzT1HsMC9VthMqXfmuRS_37crB-9bVfIRHeOs,19631
 qubx/core/initializer.py,sha256=PUiD_cIjvGpuPjYyRpUjpwm3xNQ2Kipa8bAhbtxCQRo,3935
-qubx/core/interfaces.py,sha256=HHe4t5AhHmdLUpe2200fA_MNloNU_iiLvhKhXr6qOaI,57468
+qubx/core/interfaces.py,sha256=sUs1oIcLI3ZZL78Cl9IewTpEtAERfuAiZ57xrP4HNrs,57444
 qubx/core/loggers.py,sha256=eYhJANHYwz1heeFMa5V7jYCL196wkTSvj6c-8lkPj1Y,19567
 qubx/core/lookups.py,sha256=KBE0ab4eheA6C5C-RIND_svYhE7Glb4CSlLRjMhPNRc,15906
 qubx/core/metrics.py,sha256=2AocZUYwoZE8OvScN3ULa-wyVregzlCn722QIZUe7Q8,57784
@@ -46,11 +47,11 @@ qubx/core/mixins/processing.py,sha256=dqehukrfqcLy5BeILKnkpHCvva4SbLKj1ZbQdnByu1
 qubx/core/mixins/subscription.py,sha256=J_SX0CNw2bPy4bhxe0vswvDXY4LCkwXSaj_1PepKRLY,8540
 qubx/core/mixins/trading.py,sha256=wqG-o7PxUZLd_yUAg0MUbq2LfnXmTcBLETrGv8vs9jU,6819
 qubx/core/mixins/universe.py,sha256=1oqOadbVB9nlvQQp2jDRhUvsSQkyxdoNgswxnxHTcs4,10653
-qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=GMsr0FgX5481EP68ZAwkLzKog85KnDCSJfND0h9_ZMc,978280
+qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=GK9DRBxZYO3ReW8861L8LC39bjk54BKNAAlCrr1KiOU,978280
 qubx/core/series.pxd,sha256=jBdMwgO8J4Zrue0e_xQ5RlqTXqihpzQNu6V3ckZvvpY,3978
 qubx/core/series.pyi,sha256=RaHm_oHHiWiNUMJqVfx5FXAXniGLsHxUFOUpacn7GC0,4604
 qubx/core/series.pyx,sha256=7DTYRj5D6O_O5MoDBj_FBjQh2zdxofi3912AnlZ7BiY,46477
-qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=8cd5oHCkH5TGcXblIHiBIz5H8NBhnvMyb98uGtF1Hfg,86568
+qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=Wgpzupp_ZIIRrY4m_GRoIpFXfb8LQxlOXsUIvcSjLeU,86568
 qubx/core/utils.pyi,sha256=a-wS13V2p_dM1CnGq40JVulmiAhixTwVwt0ah5By0Hc,348
 qubx/core/utils.pyx,sha256=k5QHfEFvqhqWfCob89ANiJDKNG8gGbOh-O4CVoneZ8M,1696
 qubx/data/__init__.py,sha256=ELZykvpPGWc5rX7QoNyNQwMLgdKMG8MACOByA4pM5hA,549
@@ -111,10 +112,10 @@ qubx/restorers/signal.py,sha256=DBLqA7vDhoMTAzUC4N9UerrO0GbjeHdTeMoCz7U7iI8,6621
 qubx/restorers/state.py,sha256=ePmh604fp2kRYzMNXL-TWvZOxmtTGAaKYfHJcnKResY,4042
 qubx/restorers/utils.py,sha256=We2gfqwQKWziUYhuUnjb-xo-5tSlbuHWpPQn0CEMTn0,1155
 qubx/ta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=55CCENeW3hatx-i8u2AhMcfofHrfR9gNauS1dd52tDk,654440
-qubx/ta/indicators.pxd,sha256=eCJ9paOxtxbDFx4U5CUhcgB1jjCQAfVqMF2FnbJ03Lo,4222
+qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=qmqUiyajgSh8E1aWvOY32KMbVxOhHDhkcFSUjtx5Evo,654440
+qubx/ta/indicators.pxd,sha256=Goo0_N0Xnju8XGo3Xs-3pyg2qr_0Nh5C-_26DK8U_IE,4224
 qubx/ta/indicators.pyi,sha256=19W0uERft49In5bf9jkJHkzJYEyE9gzudN7_DJ5Vdv8,1963
-qubx/ta/indicators.pyx,sha256=FVkv5ld04TpZMT3a_kR1MU3IUuWfijzjJnh_lG78JxM,26029
+qubx/ta/indicators.pyx,sha256=Xgpew46ZxSXsdfSEWYn3A0Q35MLsopB9n7iyCsXTufs,25969
 qubx/trackers/__init__.py,sha256=ThIP1jXaACse5hG3lZqQSlWSKYl6APxFmBHaRcVpPdU,1002
 qubx/trackers/advanced.py,sha256=WiYqihr5ZIY74DjiCzyMCywB7F1wTt71qrXqlzzIbZQ,12764
 qubx/trackers/composite.py,sha256=W-n1vd4l-RZEoojj6lICqvJ8EgTV2kE6JUUmZUkZ1cI,6339
@@ -144,11 +145,11 @@ qubx/utils/runner/_jupyter_runner.pyt,sha256=41dLQeI2EL4wJjBDht2qKbgISgS5DtmJ6Xt
 qubx/utils/runner/accounts.py,sha256=brf_RP22-nFlpyLg-eES-4pCikqev-I7OHa2bnLDK6o,3304
 qubx/utils/runner/configs.py,sha256=Sr4h-1d84Im29_nNtHu_UCQh1-MJGudU9MvIZmh2sWA,3462
 qubx/utils/runner/factory.py,sha256=vQ2dBTbrQE9YH__-TvuFzGF-E1li-vt_qQum9GHa11g,11666
-qubx/utils/runner/runner.py,sha256=hZZHIFTjSSUA1ZHjE-4e4vkQMzMI25CbJ_70B7blEE0,27967
+qubx/utils/runner/runner.py,sha256=03w1pZdbiXuGdcUbPy3_HLUoCk20IzmAL58FSXCYMNE,28216
 qubx/utils/time.py,sha256=J0ZFGjzFL5T6GA8RPAel8hKG0sg2LZXeQ5YfDCfcMHA,10055
 qubx/utils/version.py,sha256=e52fIHyxzCiIuH7svCF6pkHuDlqL64rklqz-2XjWons,5309
-qubx-0.6.21.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
-qubx-0.6.21.dist-info/METADATA,sha256=ZBSDCYBQaxLVX-liMdUciuy5SYmMaVcDHo1B3Ts1YQ8,4444
-qubx-0.6.21.dist-info/WHEEL,sha256=h1DdjcD2ZFnKGsDLjEycQhNNPJ5l-R8qdFdDSXHrAGY,110
-qubx-0.6.21.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
-qubx-0.6.21.dist-info/RECORD,,
+qubx-0.6.23.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
+qubx-0.6.23.dist-info/METADATA,sha256=w1vDSRGZxYqvAKCoJUlT3605G_03Y4IHsMjbPafcRyk,4444
+qubx-0.6.23.dist-info/WHEEL,sha256=XjdW4AGUgFDhpG9b3b2KPhtR_JLZvHyfemLgJJwcqOI,110
+qubx-0.6.23.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
+qubx-0.6.23.dist-info/RECORD,,

{qubx-0.6.21.dist-info → qubx-0.6.23.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.1
+Generator: poetry-core 2.1.2
 Root-Is-Purelib: false
 Tag: cp312-cp312-manylinux_2_39_x86_64