Qubx 0.2.72__tar.gz → 0.2.74__tar.gz

{qubx-0.2.72 → qubx-0.2.74}/PKG-INFO

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

{qubx-0.2.72 → qubx-0.2.74}/pyproject.toml

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

{qubx-0.2.72 → qubx-0.2.74}/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.72 → qubx-0.2.74}/src/qubx/backtester/optimization.py

@@ -90,7 +90,41 @@ def permutate_params(
     return _wrap_single_list(result) if wrap_as_list else result
 
 
-def variate(clz: Type[Any] | List[Type[Any]], *args, conditions=None, **kwargs) -> Dict[str, Any]:
+def dicts_product(d1: dict, d2: dict) -> dict:
+    """
+    Product of two dictionaries.
+
+    Example:
+    -------
+
+    dicts_product({
+        'A': 1,
+        'B': 2,
+    }, {
+        'C': 3,
+        'D': 4,
+    })
+
+    Output:
+    ------
+    {
+        'A + C': [1, 3],
+        'A + D': [1, 4],
+        'B + C': [2, 3],
+        'B + D': [2, 4]
+    }
+
+    """
+    flatten = lambda l: [item for sublist in l for item in (sublist if isinstance(sublist, list) else [sublist])]
+    return {(a + " + " + b): flatten([d1[a], d2[b]]) for a, b in product(d1.keys(), d2.keys())}
+
+
+class _dict(dict):
+    def __add__(self, other: dict) -> dict:
+        return _dict(dicts_product(self, other))
+
+
+def variate(clz: Type[Any] | List[Type[Any]], *args, conditions=None, **kwargs) -> _dict:
     """
     Make variations of parameters for simulations (micro optimizer)
 
@@ -149,7 +183,9 @@ def variate(clz: Type[Any] | List[Type[Any]], *args, conditions=None, **kwargs)
     to_excl = [s for s, v in kwargs.items() if not isinstance(v, (list, set, tuple, range))]
     dic2str = lambda ds: [_cmprss(k) + "=" + str(v) for k, v in ds.items() if k not in to_excl]
 
-    return {
-        f"{sfx}_({ ','.join(dic2str(z)) })": _mk(clz, *args, **z)
-        for z in permutate_params(kwargs, conditions=conditions)
-    }
+    return _dict(
+        {
+            f"{sfx}_({ ','.join(dic2str(z)) })": _mk(clz, *args, **z)
+            for z in permutate_params(kwargs, conditions=conditions)
+        }
+    )

{qubx-0.2.72 → qubx-0.2.74}/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
@@ -521,7 +556,7 @@ class SimulatedExchange(IBrokerServiceProvider):
             # we have to schedule possible crons before sending the data event itself
             if self._scheduler.check_and_run_tasks():
                 # - push nothing - it will force to process last event
-                cc.send((None, "time", None))
+                cc.send((None, "service_time", None))
 
         cc.send((symbol, data_type, data))
 
@@ -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.72 → qubx-0.2.74}/src/qubx/core/helpers.py

@@ -300,9 +300,9 @@ class BasicScheduler:
         next_time = iter.get_next(start_time=start_time)
         if next_time:
             self._scdlr.enterabs(next_time, 1, self._trigger, (event, prev_time, next_time))
-            logger.debug(
-                f"Now is <red>{_SEC2TS(self.time_sec())}</red> next ({event}) at <cyan>{_SEC2TS(next_time)}</cyan>"
-            )
+            # logger.debug(
+            #     f"Now is <red>{_SEC2TS(self.time_sec())}</red> next ({event}) at <cyan>{_SEC2TS(next_time)}</cyan>"
+            # )
             return True
         logger.debug(f"({event}) task is not scheduled")
         return False

{qubx-0.2.72 → qubx-0.2.74}/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.72 → qubx-0.2.74}/src/qubx/data/readers.py

@@ -1027,7 +1027,6 @@ class QuestDBSqlOrderBookBuilder(QuestDBSqlCandlesBuilder):
     Sql builder for snapshot data
     """
 
-    MAX_TIME_DELTA = pd.Timedelta("5h")
     SNAPSHOT_DELTA = pd.Timedelta("1h")
     MIN_DELTA = pd.Timedelta("1s")
 
@@ -1043,8 +1042,6 @@ class QuestDBSqlOrderBookBuilder(QuestDBSqlCandlesBuilder):
             raise ValueError("Start and end dates must be provided for orderbook data!")
         start_dt, end_dt = pd.Timestamp(start), pd.Timestamp(end)
         delta = end_dt - start_dt
-        if delta > self.MAX_TIME_DELTA:
-            raise ValueError(f"Time range is too big for orderbook data: {delta}, max allowed: {self.MAX_TIME_DELTA}")
 
         raw_start_dt = start_dt.floor(self.SNAPSHOT_DELTA) - self.MIN_DELTA
 

{qubx-0.2.72 → qubx-0.2.74}/src/qubx/trackers/riskctrl.py

@@ -5,7 +5,7 @@ from typing import Dict, List, Literal
 import numpy as np
 
 from qubx import logger
-from qubx.core.basics import Deal, Instrument, Signal, TargetPosition
+from qubx.core.basics import Deal, Instrument, OrderStatus, Signal, TargetPosition
 from qubx.core.series import Bar, Quote, Trade
 from qubx.core.strategy import IPositionSizer, PositionsTracker, StrategyContext
 from qubx.trackers.sizers import FixedRiskSizer, FixedSizer
@@ -270,6 +270,15 @@ class BrokerSideRiskController(RiskController):
                         )
                         order = ctx.trade(instrument, -pos, c_w.target.take)
                         c_w.take_order_id = order.id
+
+                        # - if order was executed immediately we don't need to send stop order
+                        if order.status == "CLOSED":
+                            c_w.status = State.RISK_TRIGGERED
+                            logger.debug(
+                                f"<yellow>{self.__class__.__name__}</yellow> <g>TAKE PROFIT</g> was exected immediately for <green>{instrument.symbol}</green> at {c_w.target.take}"
+                            )
+                            return
+
                     except Exception as e:
                         logger.error(
                             f"<yellow>{self.__class__.__name__}</yellow> couldn't send take limit order for <green>{instrument.symbol}</green>: {str(e)}"

{qubx-0.2.72 → qubx-0.2.74}/src/qubx/utils/time.py

@@ -113,7 +113,7 @@ def infer_series_frequency(series: Union[List, pd.DataFrame, pd.Series, pd.Datet
             [
                 (
                     x
-                    if isinstance(x, (np.timedelta64, int))
+                    if isinstance(x, (np.timedelta64, int, np.int64))
                     else int(x) if isinstance(x, float) else int(1e9 * x.total_seconds())
                 )
                 for x in np.abs(np.diff(times_index))