Qubx 0.2.64__cp311-cp311-manylinux_2_35_x86_64.whl → 0.2.69__cp311-cp311-manylinux_2_35_x86_64.whl

qubx/backtester/ome.py

@@ -6,7 +6,19 @@ import numpy as np
 from sortedcontainers import SortedDict
 
 from qubx import logger
-from qubx.core.basics import Deal, Instrument, Order, Position, Signal, TransactionCostsCalculator, dt_64, ITimeProvider
+from qubx.core.basics import (
+    Deal,
+    Instrument,
+    Order,
+    OrderSide,
+    OrderType,
+    Position,
+    Signal,
+    TransactionCostsCalculator,
+    dt_64,
+    ITimeProvider,
+    OPTION_FILL_AT_SIGNAL_PRICE,
+)
 from qubx.core.series import Quote, Trade
 from qubx.core.exceptions import (
     ExchangeError,
@@ -25,6 +37,7 @@ class OrdersManagementEngine:
     instrument: Instrument
     time_service: ITimeProvider
     active_orders: Dict[str, Order]
+    stop_orders: Dict[str, Order]
     asks: SortedDict[float, List[str]]
     bids: SortedDict[float, List[str]]
     bbo: Quote | None  # current best bid/ask order book (simplest impl)
@@ -40,6 +53,7 @@ class OrdersManagementEngine:
         self.asks = SortedDict()
         self.bids = SortedDict(neg)
         self.active_orders = dict()
+        self.stop_orders = dict()
         self.bbo = None
         self.__order_id = 100000
         self.__trade_id = 100000
@@ -58,7 +72,7 @@ class OrdersManagementEngine:
         return self.bbo
 
     def get_open_orders(self) -> List[Order]:
-        return list(self.active_orders.values())
+        return list(self.active_orders.values()) + list(self.stop_orders.values())
 
     def update_bbo(self, quote: Quote) -> List[OmeReport]:
         timestamp = self.time_service.time()
@@ -79,18 +93,30 @@ class OrdersManagementEngine:
                         rep.append(self._execute_order(timestamp, order.price, order, False))
                     self.bids.pop(level)
 
+            # - processing stop orders
+            for soid in list(self.stop_orders.keys()):
+                so = self.stop_orders[soid]
+                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
+                    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
+                    self.stop_orders.pop(soid)
+                    rep.append(self._execute_order(timestamp, _exec_price, so, True))
+
         self.bbo = quote
         return rep
 
     def place_order(
         self,
-        order_side: str,
-        order_type: str,
+        order_side: OrderSide,
+        order_type: OrderType,
         amount: float,
         price: float | None = None,
         client_id: str | None = None,
         time_in_force: str = "gtc",
-        fill_at_price: bool = False,
+        **options,
     ) -> OmeReport:
 
         if self.bbo is None:
@@ -113,14 +139,15 @@ class OrdersManagementEngine:
             "NEW",
             time_in_force,
             client_id,
+            options=options,
         )
 
-        return self._process_order(timestamp, order, fill_at_price=fill_at_price)
+        return self._process_order(timestamp, order)
 
     def _dbg(self, message, **kwargs) -> None:
         logger.debug(f"[OMS] {self.instrument.symbol} - {message}", **kwargs)
 
-    def _process_order(self, timestamp: dt_64, order: Order, fill_at_price: bool = False) -> OmeReport:
+    def _process_order(self, timestamp: dt_64, order: Order) -> OmeReport:
         if order.status in ["CLOSED", "CANCELED"]:
             raise InvalidOrder(f"Order {order.id} is already closed or canceled.")
 
@@ -130,33 +157,45 @@ class OrdersManagementEngine:
 
         # - check if order can be "executed" immediately
         exec_price = None
-        if fill_at_price and order.price:
-            exec_price = order.price
+        _need_update_book = False
 
-        elif order.type == "MARKET":
+        if order.type == "MARKET":
             exec_price = c_ask if buy_side else c_bid
 
         elif order.type == "LIMIT":
+            _need_update_book = True
             if (buy_side and order.price >= c_ask) or (not buy_side and order.price <= c_bid):
                 exec_price = c_ask if buy_side else c_bid
 
+        elif order.type == "STOP_MARKET":
+            # - it processes stop orders separately without adding to orderbook (as on real exchanges)
+            order.status = "OPEN"
+            self.stop_orders[order.id] = order
+
+        elif order.type == "STOP_LIMIT":
+            # TODO: check trigger conditions in options etc
+            raise NotImplementedError("'STOP_LIMIT' order is not supported in Qubx simulator yet !")
+
         # - if order must be "executed" immediately
         if exec_price is not None:
             return self._execute_order(timestamp, exec_price, order, True)
 
         # - processing limit orders
-        if buy_side:
-            self.bids.setdefault(order.price, list()).append(order.id)
-        else:
-            self.asks.setdefault(order.price, list()).append(order.id)
-        order.status = "OPEN"
+        if _need_update_book:
+            if buy_side:
+                self.bids.setdefault(order.price, list()).append(order.id)
+            else:
+                self.asks.setdefault(order.price, list()).append(order.id)
+
+            order.status = "OPEN"
+            self.active_orders[order.id] = order
+
         self._dbg(f"registered {order.id} {order.type} {order.side} {order.quantity} {order.price}")
-        self.active_orders[order.id] = order
         return OmeReport(timestamp, order, None)
 
     def _execute_order(self, timestamp: dt_64, exec_price: float, order: Order, taker: bool) -> OmeReport:
         order.status = "CLOSED"
-        self._dbg(f"{order.id} {order.type} {order.side} {order.quantity} executed at {exec_price}")
+        self._dbg(f"<red>{order.id}</red> {order.type} {order.side} {order.quantity} executed at {exec_price}")
         return OmeReport(
             timestamp,
             order,
@@ -180,38 +219,51 @@ class OrdersManagementEngine:
         if order_side.upper() not in ["BUY", "SELL"]:
             raise InvalidOrder("Invalid order side. Only BUY or SELL is allowed.")
 
-        if order_type.upper() not in ["LIMIT", "MARKET"]:
-            raise InvalidOrder("Invalid order type. Only LIMIT or MARKET is supported.")
+        _ot = order_type.upper()
+        if _ot not in ["LIMIT", "MARKET", "STOP_MARKET", "STOP_LIMIT"]:
+            raise InvalidOrder("Invalid order type. Only LIMIT, MARKET, STOP_MARKET, STOP_LIMIT are supported.")
 
         if amount <= 0:
             raise InvalidOrder("Invalid order amount. Amount must be positive.")
 
-        if order_type.upper() == "LIMIT" and (price is None or price <= 0):
-            raise InvalidOrder("Invalid order price. Price must be positively defined for LIMIT orders.")
+        if (_ot == "LIMIT" or _ot.startswith("STOP")) and (price is None or price <= 0):
+            raise InvalidOrder("Invalid order price. Price must be positively defined for LIMIT or STOP orders.")
 
         if time_in_force.upper() not in ["GTC", "IOC"]:
             raise InvalidOrder("Invalid time in force. Only GTC or IOC is supported for now.")
 
-    def cancel_order(self, order_id: str) -> OmeReport:
-        if order_id not in self.active_orders:
-            raise InvalidOrder(f"Order {order_id} not found for {self.instrument.symbol}")
+        if _ot.startswith("STOP"):
+            assert price is not None
+            c_ask, c_bid = self.bbo.ask, self.bbo.bid
+            if (order_side == "BUY" and c_ask >= price) or (order_side == "SELL" and c_bid <= price):
+                raise ExchangeError(
+                    f"Stop price would trigger immediately: STOP_MARKET {order_side} {amount} of {self.instrument.symbol} at {price} | market: {c_ask} / {c_bid}"
+                )
 
-        timestamp = self.time_service.time()
-        order = self.active_orders.pop(order_id)
-        if order.side == "BUY":
-            oids = self.bids[order.price]
-            oids.remove(order_id)
-            if not oids:
-                self.bids.pop(order.price)
+    def cancel_order(self, order_id: str) -> OmeReport:
+        # - check limit orders
+        if order_id in self.active_orders:
+            order = self.active_orders.pop(order_id)
+            if order.side == "BUY":
+                oids = self.bids[order.price]
+                oids.remove(order_id)
+                if not oids:
+                    self.bids.pop(order.price)
+            else:
+                oids = self.asks[order.price]
+                oids.remove(order_id)
+                if not oids:
+                    self.asks.pop(order.price)
+        # - check stop orders
+        elif order_id in self.stop_orders:
+            order = self.stop_orders.pop(order_id)
+        # - wrong order_id
         else:
-            oids = self.asks[order.price]
-            oids.remove(order_id)
-            if not oids:
-                self.asks.pop(order.price)
+            raise InvalidOrder(f"Order {order_id} not found for {self.instrument.symbol}")
 
         order.status = "CANCELED"
         self._dbg(f"{order.id} {order.type} {order.side} {order.quantity} canceled")
-        return OmeReport(timestamp, order, None)
+        return OmeReport(self.time_service.time(), order, None)
 
     def __str__(self) -> str:
         _a, _b = True, True

qubx/backtester/simulator.py

@@ -125,7 +125,7 @@ class _SimulatedLogFormatter:
 
         now = self.time_provider.time().astype("datetime64[us]").item().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
         # prefix = "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> [ <level>%s</level> ] " % record["level"].icon
-        prefix = f"<yellow>{now}</yellow> [ <level>{record['level'].icon}</level> ] "
+        prefix = f"<lc>{now}</lc> [<level>{record['level'].icon}</level>] "
 
         if record["exception"] is not None:
             record["extra"]["stack"] = stackprinter.format(record["exception"], style="darkbg3")
@@ -201,7 +201,7 @@ class SimulatedTrading(ITradingServiceProvider):
             price,
             client_id,
             time_in_force,
-            fill_at_price=options.get("fill_at_price", False),
+            **options,
         )
         order = report.order
         self._order_to_symbol[order.id] = instrument.symbol
@@ -362,7 +362,7 @@ class SimulatedExchange(IBrokerServiceProvider):
 
         # - create exchange's instance
         self._last_quotes = defaultdict(lambda: None)
-        self._current_time = np.datetime64(0, "ns")
+        self._current_time = self.trading_service.time()
         self._loaders = defaultdict(dict)
         self._symbol_to_instrument: dict[str, Instrument] = {}
 
@@ -509,20 +509,22 @@ class SimulatedExchange(IBrokerServiceProvider):
         self._current_time = max(np.datetime64(t, "ns"), self._current_time)
         q = self.trading_service.emulate_quote_from_data(symbol, np.datetime64(t, "ns"), data)
         is_hist = data_type.startswith("hist")
+
         if not is_hist and q is not None:
             self._last_quotes[symbol] = q
             self.trading_service.update_position_price(symbol, self._current_time, q)
 
+            # 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((symbol, data_type, data))
 
         if not is_hist:
             if q is not None and data_type != "quote":
                 cc.send((symbol, "quote", q))
 
-            if self._scheduler.check_and_run_tasks():
-                # - push nothing - it will force to process last event
-                cc.send((None, "time", None))
-
     def get_quote(self, symbol: str) -> Optional[Quote]:
         return self._last_quotes[symbol]
 
@@ -783,7 +785,7 @@ def find_instruments_and_exchanges(
     return _instrs, _exchanges
 
 
-class _GeneratedSignalsStrategy(IStrategy):
+class SignalsProxy(IStrategy):
 
     def on_fit(
         self, ctx: StrategyContext, fit_time: str | pd.Timestamp, previous_fit_time: str | pd.Timestamp | None = None
@@ -870,7 +872,7 @@ def _run_setup(
             strat.tracker = lambda ctx: setup.tracker  # type: ignore
 
         case _Types.SIGNAL:
-            strat = _GeneratedSignalsStrategy()
+            strat = SignalsProxy()
             exchange.set_generated_signals(setup.generator)  # type: ignore
             # - we don't need any unexpected triggerings
             _trigger = "bar: 0s"
@@ -880,7 +882,7 @@ def _run_setup(
             enable_event_batching = False
 
         case _Types.SIGNAL_AND_TRACKER:
-            strat = _GeneratedSignalsStrategy()
+            strat = SignalsProxy()
             strat.tracker = lambda ctx: setup.tracker
             exchange.set_generated_signals(setup.generator)  # type: ignore
             # - we don't need any unexpected triggerings

qubx/core/basics.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, List, Literal, Optional, Tuple, Union
 import numpy as np
 import pandas as pd
 from dataclasses import dataclass, field
@@ -14,6 +14,8 @@ from qubx.core.utils import prec_ceil, prec_floor
 dt_64 = np.datetime64
 td_64 = np.timedelta64
 
+OPTION_FILL_AT_SIGNAL_PRICE = "fill_at_signal_price"
+
 
 @dataclass
 class Signal:
@@ -24,7 +26,6 @@ class Signal:
         reference_price: float - exact price when signal was generated
 
         Options:
-        - fill_at_signal_price: bool - if True, then fill order at signal price (only used in backtesting)
         - allow_override: bool - if True, and there is another signal for the same instrument, then override current.
     """
 
@@ -58,15 +59,23 @@ class TargetPosition:
     time: dt_64  # time when position was set
     signal: Signal  # original signal
     target_position_size: float  # actual position size after processing in sizer
+    _is_service: bool = False
 
     @staticmethod
     def create(ctx: "ITimeProvider", signal: Signal, target_size: float) -> "TargetPosition":
-        return TargetPosition(ctx.time(), signal, target_size)
+        return TargetPosition(ctx.time(), signal, signal.instrument.round_size_down(target_size))
 
     @staticmethod
     def zero(ctx: "ITimeProvider", signal: Signal) -> "TargetPosition":
         return TargetPosition(ctx.time(), signal, 0.0)
 
+    @staticmethod
+    def service(ctx: "ITimeProvider", signal: Signal, size: float | None = None) -> "TargetPosition":
+        """
+        Generate just service position target (for logging purposes)
+        """
+        return TargetPosition(ctx.time(), signal, size if size else signal.signal, _is_service=True)
+
     @property
     def instrument(self) -> "Instrument":
         return self.signal.instrument
@@ -83,8 +92,15 @@ class TargetPosition:
     def take(self) -> float | None:
         return self.signal.take
 
+    @property
+    def is_service(self) -> bool:
+        """
+        Some target may be used just for informative purposes (post-factum risk management etc)
+        """
+        return self._is_service
+
     def __str__(self) -> str:
-        return f"Target for {self.signal} -> {self.target_position_size} at {self.time}"
+        return f"{'::: INFORMATIVE ::: ' if self.is_service else ''}Target for {self.signal} -> {self.target_position_size} at {self.time}"
 
 
 @dataclass
@@ -284,19 +300,25 @@ class Deal:
     fee_currency: str | None = None
 
 
+OrderType = Literal["MARKET", "LIMIT", "STOP_MARKET", "STOP_LIMIT"]
+OrderSide = Literal["BUY", "SELL"]
+OrderStatus = Literal["OPEN", "CLOSED", "CANCELED", "NEW"]
+
+
 @dataclass
 class Order:
     id: str
-    type: str
+    type: OrderType
     symbol: str
     time: dt_64
     quantity: float
     price: float
-    side: str
-    status: str
+    side: OrderSide
+    status: OrderStatus
     time_in_force: str
     client_id: str | None = None
     cost: float = 0.0
+    options: dict[str, Any] = field(default_factory=dict)
 
     def __str__(self) -> str:
         return f"[{self.id}] {self.type} {self.side} {self.quantity} of {self.symbol} {('@ ' + str(self.price)) if self.price > 0 else ''} ({self.time_in_force}) [{self.status}]"

qubx/core/context.py

@@ -381,7 +381,7 @@ class StrategyContextImpl(StrategyContext):
             # - process and execute signals if they are provided
             if signals:
                 # process signals by tracker and turn convert them into positions
-                positions_from_strategy = self.__process_target_positions(
+                positions_from_strategy = self.__process_and_log_target_positions(
                     self.positions_tracker.process_signals(self, self.__process_signals(signals))
                 )
 
@@ -415,11 +415,11 @@ class StrategyContextImpl(StrategyContext):
         try:
             self.__fit_is_running = True
             logger.debug(
-                f"[{self.time()}]: Invoking {self.strategy.__class__.__name__} on_fit('{current_fit_time}', '{prev_fit_time}')"
+                f"Invoking <green>{self.strategy.__class__.__name__}</green> on_fit('{current_fit_time}', '{prev_fit_time}')"
             )
             _SW.start("strategy.on_fit")
             self.strategy.on_fit(self, current_fit_time, prev_fit_time)
-            logger.debug(f"[{self.time()}]: {self.strategy.__class__.__name__} is fitted")
+            logger.debug(f"<green>{self.strategy.__class__.__name__}</green> is fitted")
         except Exception as strat_error:
             logger.error(
                 f"[{self.time()}]: Strategy {self.strategy.__class__.__name__} on_fit('{current_fit_time}', '{prev_fit_time}') raised an exception: {strat_error}"
@@ -505,13 +505,12 @@ class StrategyContextImpl(StrategyContext):
         elif signals is None:
             return []
 
-        # set strategy group name if not set
         for signal in signals:
+            # set strategy group name if not set
             if not signal.group:
                 signal.group = self.strategy_name
 
-        # set reference prices for signals
-        for signal in signals:
+            # set reference prices for signals
             if signal.reference_price is None:
                 q = self.quote(signal.instrument.symbol)
                 if q is None:
@@ -530,9 +529,10 @@ class StrategyContextImpl(StrategyContext):
         signals = [pos.signal for pos in target_positions]
         self.__process_signals(signals)
 
-    def __process_target_positions(
+    def __process_and_log_target_positions(
         self, target_positions: List[TargetPosition] | TargetPosition | None
     ) -> List[TargetPosition]:
+
         if isinstance(target_positions, TargetPosition):
             target_positions = [target_positions]
         elif target_positions is None:
@@ -548,7 +548,10 @@ class StrategyContextImpl(StrategyContext):
 
         # - update tracker and handle alterd positions if need
         self.positions_gathering.alter_positions(
-            self, self.__process_target_positions(self.positions_tracker.update(self, self._symb_to_instr[symbol], bar))
+            self,
+            self.__process_and_log_target_positions(
+                self.positions_tracker.update(self, self._symb_to_instr[symbol], bar)
+            ),
         )
 
         # - check if it's time to trigger the on_event if it's configured
@@ -570,7 +573,7 @@ class StrategyContextImpl(StrategyContext):
         # - update tracker and handle alterd positions if need
         self.positions_gathering.alter_positions(
             self,
-            self.__process_target_positions(target_positions),
+            self.__process_and_log_target_positions(target_positions),
         )
 
         if self._trig_on_trade:
@@ -585,7 +588,7 @@ class StrategyContextImpl(StrategyContext):
         self.__process_signals_from_target_positions(target_positions)
 
         # - update tracker and handle alterd positions if need
-        self.positions_gathering.alter_positions(self, self.__process_target_positions(target_positions))
+        self.positions_gathering.alter_positions(self, self.__process_and_log_target_positions(target_positions))
 
         # - TODO: here we can apply throttlings or filters
         #  - let's say we can skip quotes if bid & ask is not changed
@@ -599,7 +602,7 @@ class StrategyContextImpl(StrategyContext):
     @_SW.watch("StrategyContext")
     def _processing_order(self, symbol: str, order: Order) -> TriggerEvent | None:
         logger.debug(
-            f"[{order.id} / {order.client_id}] : {order.type} {order.side} {order.quantity} of {symbol} { (' @ ' + str(order.price)) if order.price else '' } -> [{order.status}]"
+            f"[<red>{order.id}</red> / {order.client_id}] : {order.type} {order.side} {order.quantity} of {symbol} { (' @ ' + str(order.price)) if order.price else '' } -> [{order.status}]"
         )
         # - check if we want to trigger any strat's logic on order
         return None
@@ -620,7 +623,7 @@ class StrategyContextImpl(StrategyContext):
                 # - notify position gatherer and tracker
                 self.positions_gathering.on_execution_report(self, instr, d)
                 self.positions_tracker.on_execution_report(self, instr, d)
-                logger.debug(f"Executed {d.amount} @ {d.price} of {symbol} for order {d.order_id}")
+                logger.debug(f"Executed {d.amount} @ {d.price} of {symbol} for order <red>{d.order_id}</red>")
         else:
             logger.debug(f"Execution report for unknown instrument {symbol}")
         return None
@@ -716,14 +719,17 @@ class StrategyContextImpl(StrategyContext):
             raise ValueError(f"Attempt to trade size {abs(amount)} less than minimal allowed {instrument.min_size} !")
 
         side = "buy" if amount > 0 else "sell"
-        type = "limit" if price is not None else "market"
-        logger.debug(f"(StrategyContext) sending {type} {side} for {size_adj} of {instrument.symbol} ...")
-        client_id = self._generate_order_client_id(instrument.symbol)
+        type = "market"
+        if price is not None:
+            price = instrument.round_price_down(price) if amount > 0 else instrument.round_price_up(price)
+            type = "limit"
+            if (stp_type := options.get("stop_type")) is not None:
+                type = f"stop_{stp_type}"
 
-        if self.broker_provider.is_simulated_trading and options.get("fill_at_price", False):
-            # assume worst case, if we force execution and certain price, assume it's via market
-            # TODO: add an additional flag besides price to indicate order type
-            type = "market"
+        logger.debug(
+            f"(StrategyContext) sending {type} {side} for {size_adj} of <green>{instrument.symbol}</green> @ {price} ..."
+        )
+        client_id = self._generate_order_client_id(instrument.symbol)
 
         order = self.trading_service.send_order(
             instrument, side, type, size_adj, price, time_in_force=time_in_force, client_id=client_id, **options
@@ -741,6 +747,10 @@ class StrategyContextImpl(StrategyContext):
         for o in self.trading_service.get_orders(instrument.symbol):
             self.trading_service.cancel_order(o.id)
 
+    def cancel_order(self, order_id: str):
+        if order_id:
+            self.trading_service.cancel_order(order_id)
+
     def quote(self, symbol: str) -> Quote | None:
         return self.broker_provider.get_quote(symbol)
 

qubx/core/loggers.py

@@ -353,6 +353,7 @@ class SignalsLogger(_BaseIntervalDumper):
                     "stop": s.stop,
                     "group": s.signal.group,
                     "comment": s.signal.comment,
+                    "service": s.is_service,
                 }
             )
         self._targets.clear()