Qubx 0.2.71__tar.gz → 0.2.73__tar.gz

{qubx-0.2.71 → qubx-0.2.73}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Qubx
-Version: 0.2.71
+Version: 0.2.73
 Summary: Qubx - quantitative trading framework
 Home-page: https://github.com/dmarienko/Qubx
 Author: Dmitry Marienko

{qubx-0.2.71 → qubx-0.2.73}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "Qubx"
-version = "0.2.71"
+version = "0.2.73"
 description = "Qubx - quantitative trading framework"
 authors = ["Dmitry Marienko <dmitry@gmail.com>", "Yuriy Arabskyy <yuriy.arabskyy@gmail.com>"]
 readme = "README.md"

{qubx-0.2.71 → qubx-0.2.73}/src/qubx/backtester/ome.py

@@ -43,9 +43,15 @@ class OrdersManagementEngine:
     bbo: Quote | None  # current best bid/ask order book (simplest impl)
     __order_id: int
     __trade_id: int
+    _fill_stops_at_price: bool
 
     def __init__(
-        self, instrument: Instrument, time_provider: ITimeProvider, tcc: TransactionCostsCalculator, debug: bool = True
+        self,
+        instrument: Instrument,
+        time_provider: ITimeProvider,
+        tcc: TransactionCostsCalculator,
+        fill_stop_order_at_price: bool = False,  # emulate stop orders execution at order's exact limit price
+        debug: bool = True,
     ) -> None:
         self.instrument = instrument
         self.time_service = time_provider
@@ -57,6 +63,7 @@ class OrdersManagementEngine:
         self.bbo = None
         self.__order_id = 100000
         self.__trade_id = 100000
+        self._fill_stops_at_price = fill_stop_order_at_price
         if not debug:
             self._dbg = lambda message, **kwargs: None
 
@@ -96,12 +103,14 @@ class OrdersManagementEngine:
             # - processing stop orders
             for soid in list(self.stop_orders.keys()):
                 so = self.stop_orders[soid]
+                _emulate_price_exec = self._fill_stops_at_price or so.options.get(OPTION_FILL_AT_SIGNAL_PRICE, False)
+
                 if so.side == "BUY" and quote.ask >= so.price:
-                    _exec_price = quote.ask if not so.options.get(OPTION_FILL_AT_SIGNAL_PRICE, False) else so.price
+                    _exec_price = quote.ask if not _emulate_price_exec else so.price
                     self.stop_orders.pop(soid)
                     rep.append(self._execute_order(timestamp, _exec_price, so, True))
                 elif so.side == "SELL" and quote.bid <= so.price:
-                    _exec_price = quote.bid if not so.options.get(OPTION_FILL_AT_SIGNAL_PRICE, False) else so.price
+                    _exec_price = quote.bid if not _emulate_price_exec else so.price
                     self.stop_orders.pop(soid)
                     rep.append(self._execute_order(timestamp, _exec_price, so, True))
 

{qubx-0.2.71 → qubx-0.2.73}/src/qubx/backtester/simulator.py

@@ -142,8 +142,8 @@ class SimulatedTrading(ITradingServiceProvider):
     First implementation of a simulated broker.
     TODO:
         1. Add margin control
-        2. Need to solve problem with _get_ohlcv_data_sync (actually this method must be removed from here)
-        3. Add support for stop orders (not urgent)
+        2. Need to solve problem with _get_ohlcv_data_sync (actually this method must be removed from here) [DONE]
+        3. Add support for stop orders (not urgent) [DONE]
     """
 
     _current_time: dt_64
@@ -152,13 +152,40 @@ class SimulatedTrading(ITradingServiceProvider):
     _fees_calculator: TransactionCostsCalculator | None
     _order_to_symbol: Dict[str, str]
     _half_tick_size: Dict[str, float]
+    _fill_stop_order_at_price: bool
 
     def __init__(
         self,
         name: str,
         commissions: str | None = None,
         simulation_initial_time: dt_64 | str = np.datetime64(0, "ns"),
+        accurate_stop_orders_execution: bool = False,
     ) -> None:
+        """
+        This function sets up a simulated trading environment with following parameters.
+
+        Parameters:
+        -----------
+        name : str
+            The name of the simulated trading environment.
+        commissions : str | None, optional
+            The commission structure to be used. If None, no commissions will be applied.
+            Default is None.
+        simulation_initial_time : dt_64 | str, optional
+            The initial time for the simulation. Can be a dt_64 object or a string.
+            Default is np.datetime64(0, "ns").
+        accurate_stop_orders_execution : bool, optional
+            If True, stop orders will be executed at the exact stop order's price.
+            If False, they may be executed at the next quote that could lead to
+            significant slippage especially if simuation run on OHLC data.
+            Default is False.
+
+        Raises:
+        -------
+        ValueError
+            If the fees configuration is not found for the given name.
+
+        """
         self._current_time = (
             np.datetime64(simulation_initial_time, "ns")
             if isinstance(simulation_initial_time, str)
@@ -168,6 +195,7 @@ class SimulatedTrading(ITradingServiceProvider):
         self._ome = {}
         self._fees_calculator = lookup.fees.find(name.lower(), commissions)
         self._half_tick_size = {}
+        self._fill_stop_order_at_price = accurate_stop_orders_execution
 
         self._order_to_symbol = {}
         if self._fees_calculator is None:
@@ -177,6 +205,8 @@ class SimulatedTrading(ITradingServiceProvider):
 
         # - we want to see simulate time in log messages
         QubxLogConfig.setup_logger(QubxLogConfig.get_log_level(), _SimulatedLogFormatter(self).formatter)
+        if self._fill_stop_order_at_price:
+            logger.info(f"SimulatedExchangeService emulates stop orders executions at exact price")
 
     def send_order(
         self,
@@ -195,8 +225,8 @@ class SimulatedTrading(ITradingServiceProvider):
 
         # - try to place order in OME
         report = ome.place_order(
-            order_side.upper(),
-            order_type.upper(),
+            order_side.upper(),  # type: ignore
+            order_type.upper(),  # type: ignore
             amount,
             price,
             client_id,
@@ -254,7 +284,12 @@ class SimulatedTrading(ITradingServiceProvider):
 
         if symbol not in self.acc._positions:
             # - initiolize OME for this instrument
-            self._ome[instrument.symbol] = OrdersManagementEngine(instrument=instrument, time_provider=self, tcc=self._fees_calculator)  # type: ignore
+            self._ome[instrument.symbol] = OrdersManagementEngine(
+                instrument=instrument,
+                time_provider=self,
+                tcc=self._fees_calculator,  # type: ignore
+                fill_stop_order_at_price=self._fill_stop_order_at_price,
+            )
 
             # - initiolize empty position
             position = Position(instrument)  # type: ignore
@@ -693,8 +728,57 @@ def simulate(
     n_jobs: int = 1,
     silent: bool = False,
     enable_event_batching: bool = True,
+    accurate_stop_orders_execution: bool = False,
     debug: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None = "WARNING",
 ) -> list[TradingSessionResult]:
+    """
+    Backtest utility for trading strategies or signals using historical data.
+
+    Parameters:
+    ----------
+
+    config (StrategyOrSignals | Dict | List[StrategyOrSignals | PositionsTracker]):
+        Trading strategy or signals configuration.
+    data (Dict[str, pd.DataFrame] | DataReader):
+        Historical data for simulation, either as a dictionary of DataFrames or a DataReader object.
+    capital (float):
+        Initial capital for the simulation.
+    instruments (List[str] | Dict[str, List[str]] | None):
+        List of trading instruments or a dictionary mapping exchanges to instrument lists.
+    subscription (Dict[str, Any]):
+        Subscription details for market data.
+    trigger (str | list[str]):
+        Trigger specification for strategy execution.
+    commissions (str):
+        Commission structure for trades.
+    start (str | pd.Timestamp):
+        Start time of the simulation.
+    stop (str | pd.Timestamp | None):
+        End time of the simulation. If None, simulates until the last accessible data.
+    fit (str | None):
+        Specification for strategy fitting, if applicable.
+    exchange (str | None):
+        Exchange name if not specified in the instruments list.
+    base_currency (str):
+        Base currency for the simulation, default is "USDT".
+    leverage (float):
+        Leverage factor for trading, default is 1.0.
+    n_jobs (int):
+        Number of parallel jobs for simulation, default is 1.
+    silent (bool):
+        If True, suppresses output during simulation.
+    enable_event_batching (bool):
+        If True, enables event batching for optimization.
+    accurate_stop_orders_execution (bool):
+        If True, enables more accurate stop order execution simulation.
+    debug (Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None):
+        Logging level for debugging.
+
+    Returns:
+    --------
+    list[TradingSessionResult]:
+        A list of TradingSessionResult objects containing the results of each simulation setup.
+    """
 
     # - setup logging
     QubxLogConfig.set_log_level(debug.upper() if debug else "WARNING")
@@ -755,6 +839,7 @@ def simulate(
         n_jobs=n_jobs,
         silent=silent,
         enable_event_batching=enable_event_batching,
+        accurate_stop_orders_execution=accurate_stop_orders_execution,
     )
 
 
@@ -818,6 +903,7 @@ def _run_setups(
     n_jobs: int = -1,
     silent: bool = False,
     enable_event_batching: bool = True,
+    accurate_stop_orders_execution: bool = False,
 ) -> List[TradingSessionResult]:
     # loggers don't work well with joblib and multiprocessing in general because they contain
     # open file handlers that cannot be pickled. I found a solution which requires the usage of enqueue=True
@@ -839,6 +925,7 @@ def _run_setups(
             fit=fit,
             silent=silent,
             enable_event_batching=enable_event_batching,
+            accurate_stop_orders_execution=accurate_stop_orders_execution,
         )
         for id, s in enumerate(setups)
     )
@@ -856,13 +943,19 @@ def _run_setup(
     fit: str | None,
     silent: bool = False,
     enable_event_batching: bool = True,
+    accurate_stop_orders_execution: bool = False,
 ) -> TradingSessionResult:
     _trigger = trigger
     _stop = stop
     logger.debug(
         f"<red>{pd.Timestamp(start)}</red> Initiating simulated trading for {setup.exchange} for {setup.capital} x {setup.leverage} in {setup.base_currency}..."
     )
-    broker = SimulatedTrading(setup.exchange, setup.commissions, np.datetime64(start, "ns"))
+    broker = SimulatedTrading(
+        setup.exchange,
+        setup.commissions,
+        np.datetime64(start, "ns"),
+        accurate_stop_orders_execution=accurate_stop_orders_execution,
+    )
     exchange = SimulatedExchange(setup.exchange, broker, data_reader)
 
     # - it will store simulation results into memory

{qubx-0.2.71 → qubx-0.2.73}/src/qubx/core/series.pyi

@@ -4,12 +4,16 @@ from typing import Any, Tuple
 import pandas as pd
 
 class Bar:
+    time: int
     open: float
     high: float
     low: float
     close: float
     volume: float
+    bought_volume: float
     def __init__(self, time, open, high, low, close, volume, bought_volume=0): ...
+    def update(self, price: float, volume: float, bought_volume: float = 0) -> Bar: ...
+    def to_dict(self, skip_time: bool = False) -> dict: ...
 
 class Quote:
     time: int
@@ -44,8 +48,9 @@ class TimeSeries:
     max_series_length: int
     times: Indexed
     values: Indexed
-    def __init__(self, name, timeframe, max_series_length, process_every_update=True) -> None: ...
+    def __init__(self, name, timeframe, max_series_length=np.inf, process_every_update=True) -> None: ...
     def __getitem__(self, idx): ...
+    def __len__(self) -> int: ...
     def update(self, time: int, value: float) -> bool: ...
     def copy(self, start: int, stop: int) -> "TimeSeries": ...
     def shift(self, period: int) -> TimeSeries: ...

{qubx-0.2.71 → qubx-0.2.73}/src/qubx/gathering/simplest.py

@@ -34,7 +34,7 @@ class SimplePositionGatherer(IPositionGathering):
 
         if abs(to_trade) < instrument.min_size:
             if current_position != 0:
-                logger.warning(
+                logger.debug(
                     f"{instrument.exchange}:{instrument.symbol}: Unable change position from {current_position} to {new_size} : too small difference"
                 )
         else:
@@ -45,7 +45,7 @@ class SimplePositionGatherer(IPositionGathering):
             if at_price:
                 # - we already havbe position but it's requested to change at a specific price
                 if abs(current_position) > instrument.min_size:
-                    logger.warning(
+                    logger.debug(
                         f"<green>{instrument.symbol}</green>: Attempt to change current position {current_position} to {new_size} at {at_price} !"
                     )
 

{qubx-0.2.71 → qubx-0.2.73}/src/qubx/trackers/riskctrl.py

@@ -201,6 +201,13 @@ class BrokerSideRiskController(RiskController):
 
             case State.RISK_TRIGGERED:
                 c.status = State.DONE
+
+                # - remove from the tracking list
+                logger.debug(
+                    f"<yellow>{self.__class__.__name__}</yellow> -- stops tracking -- <green>{instrument.symbol}</green>"
+                )
+                self._trackings.pop(instrument)
+
                 # - send service signal that risk triggeres (it won't be processed by StrategyContext)
                 if c.stop_executed_price: 
                     return [
@@ -215,9 +222,6 @@ class BrokerSideRiskController(RiskController):
                             )
                     ]
 
-            case State.OPEN:
-                pass
-
             case State.DONE:
                 logger.debug(
                     f"<yellow>{self.__class__.__name__}</yellow> -- stops tracking -- <green>{instrument.symbol}</green>"