Qubx 0.2.69__tar.gz → 0.2.71__tar.gz

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

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

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

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

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

@@ -468,11 +468,13 @@ class SimulatedExchange(IBrokerServiceProvider):
 
         if silent:
             for symbol, data_type, event in qiter:
-                _run(symbol, data_type, event)
+                if not _run(symbol, data_type, event):
+                    break
         else:
             with tqdm(total=total_duration.total_seconds(), desc="Simulating", unit="s", leave=False) as pbar:
                 for symbol, data_type, event in qiter:
-                    _run(symbol, data_type, event)
+                    if not _run(symbol, data_type, event):
+                        break
                     dt = pd.Timestamp(event.time)
                     # update only if date has changed
                     if dt - prev_dt > update_delta:
@@ -484,7 +486,7 @@ class SimulatedExchange(IBrokerServiceProvider):
 
         logger.info(f"SimulatedExchangeService :: run :: Simulation finished at {end}")
 
-    def _run_generated_signals(self, symbol: str, data_type: str, data: Any) -> None:
+    def _run_generated_signals(self, symbol: str, data_type: str, data: Any) -> bool:
         is_hist = data_type.startswith("hist")
         if is_hist:
             raise ValueError("Historical data is not supported for pre-generated signals !")
@@ -503,7 +505,9 @@ class SimulatedExchange(IBrokerServiceProvider):
             cc.send((symbol, "event", {"order": sigs[0][1]}))
             sigs.pop(0)
 
-    def _run_as_strategy(self, symbol: str, data_type: str, data: Any) -> None:
+        return cc.control.is_set()
+
+    def _run_as_strategy(self, symbol: str, data_type: str, data: Any) -> bool:
         cc = self.get_communication_channel()
         t = data.time  # type: ignore
         self._current_time = max(np.datetime64(t, "ns"), self._current_time)
@@ -525,6 +529,8 @@ class SimulatedExchange(IBrokerServiceProvider):
             if q is not None and data_type != "quote":
                 cc.send((symbol, "quote", q))
 
+        return cc.control.is_set()
+
     def get_quote(self, symbol: str) -> Optional[Quote]:
         return self._last_quotes[symbol]
 

{qubx-0.2.69 → qubx-0.2.71}/src/qubx/core/basics.py

@@ -570,6 +570,12 @@ class SimulatedCtrlChannel(CtrlChannel):
     def receive(self) -> Any:
         raise ValueError("This method should not be called in a simulated environment.")
 
+    def stop(self):
+        self.control.clear()
+
+    def start(self):
+        self.control.set()
+
 
 class IComminucationManager:
     databus: CtrlChannel

qubx-0.2.71/src/qubx/gathering/simplest.py

@@ -0,0 +1,88 @@
+from qubx import logger
+from qubx.core.basics import Deal, Instrument, TargetPosition
+from qubx.core.strategy import IPositionGathering, StrategyContext
+
+
+class SimplePositionGatherer(IPositionGathering):
+    """
+    Default implementation of positions gathering by single orders through strategy context
+    """
+
+    entry_order_id: str | None = None
+
+    def _cncl_order(self, ctx: StrategyContext, instrument: Instrument) -> None:
+        if self.entry_order_id:
+            logger.debug(
+                f"<green>{instrument.symbol}</green>: Cancelling previous entry order <red>{self.entry_order_id}</red>"
+            )
+            try:
+                ctx.cancel_order(self.entry_order_id)
+            except Exception as e:
+                logger.error(f"Cancelling entry order failed: {str(e)}")
+            self.entry_order_id = None
+
+    def alter_position_size(self, ctx: StrategyContext, target: TargetPosition) -> float:
+        #  Here is default inplementation:
+        #  just trade it through the strategy context by using market (or limit) orders.
+        #  but in general it may have complex logic for position adjustment
+        instrument, new_size, at_price = target.instrument, target.target_position_size, target.price
+        current_position = ctx.positions[instrument.symbol].quantity
+        to_trade = new_size - current_position
+
+        # - first cancel previous entry order if exists
+        self._cncl_order(ctx, instrument)
+
+        if abs(to_trade) < instrument.min_size:
+            if current_position != 0:
+                logger.warning(
+                    f"{instrument.exchange}:{instrument.symbol}: Unable change position from {current_position} to {new_size} : too small difference"
+                )
+        else:
+
+            # - check how it should be traded: market or limit or stop order
+            opts = {}
+            _is_stop_or_limit = False
+            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(
+                        f"<green>{instrument.symbol}</green>: Attempt to change current position {current_position} to {new_size} at {at_price} !"
+                    )
+
+                quote = ctx.quote(instrument.symbol)
+                if (to_trade > 0 and at_price > quote.ask) or (to_trade < 0 and at_price < quote.bid):
+                    opts["stop_type"] = "market"
+                    _is_stop_or_limit = True
+
+                if (to_trade > 0 and at_price <= quote.bid) or (to_trade < 0 and at_price >= quote.ask):
+                    _is_stop_or_limit = True
+
+            r = ctx.trade(instrument, to_trade, at_price, **opts)
+            if _is_stop_or_limit:
+                self.entry_order_id = r.id
+                logger.debug(
+                    f"<green>{instrument.symbol}</green>: Position may be adjusted from {current_position} to {new_size} at {at_price} : {r}"
+                )
+            else:
+                self.entry_order_id = None
+                logger.debug(
+                    f"<green>{instrument.symbol}</green>: Adjusting position from {current_position} to {new_size} : {r}"
+                )
+
+            current_position = new_size
+            # - TODO: need to check how fast position is being updated on live
+            # current_position = ctx.positions[instrument.symbol].quantity
+
+        return current_position
+
+    def on_execution_report(self, ctx: StrategyContext, instrument: Instrument, deal: Deal):
+        if deal.order_id == self.entry_order_id:
+            self.entry_order_id = None
+
+
+class SplittedOrdersPositionGatherer(IPositionGathering):
+    """
+    Gather position by splitting order into smaller parts randomly
+    """
+
+    pass

qubx-0.2.69/src/qubx/gathering/simplest.py

@@ -1,44 +0,0 @@
-from qubx import logger
-from qubx.core.basics import Deal, Instrument, TargetPosition
-from qubx.core.strategy import IPositionGathering, StrategyContext
-
-
-class SimplePositionGatherer(IPositionGathering):
-    """
-    Default implementation of positions gathering by single orders through strategy context
-    """
-
-    def alter_position_size(self, ctx: StrategyContext, target: TargetPosition) -> float:
-        instrument, new_size, at_price = target.instrument, target.target_position_size, target.price
-        current_position = ctx.positions[instrument.symbol].quantity
-        to_trade = new_size - current_position
-        if abs(to_trade) < instrument.min_size:
-            logger.warning(
-                f"{instrument.exchange}:{instrument.symbol}: Unable change position from {current_position} to {new_size} : too small difference"
-            )
-        else:
-            # - here is default inplementation:
-            #   just trade it through the strategy context by using market (or limit) orders.
-            # - but in general it may have complex logic for position adjustment
-            r = ctx.trade(instrument, to_trade, at_price)
-            # , fill_at_price=target.signal.options.get("fill_at_signal_price", False)
-            logger.debug(
-                f"<green>{instrument.symbol}</green>: Adjusting position from {current_position} to {new_size} : {r}"
-            )
-
-            current_position = new_size
-            # - TODO: need to check how fast position is being updated on live
-            # current_position = ctx.positions[instrument.symbol].quantity
-
-        return current_position
-
-    def on_execution_report(self, ctx: StrategyContext, instrument: Instrument, deal: Deal):
-        pass
-
-
-class SplittedOrdersPositionGatherer(IPositionGathering):
-    """
-    Gather position by splitting order into smaller parts randomly
-    """
-
-    pass