Qubx 0.5.7__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/trackers/__init__.py

@@ -0,0 +1,3 @@
+from .rebalancers import PortfolioRebalancerTracker, Capital
+from .riskctrl import AtrRiskTracker
+from .sizers import FixedSizer, FixedRiskSizer, LongShortRatioPortfolioSizer

qubx/trackers/abvanced.py

@@ -0,0 +1,236 @@
+from dataclasses import dataclass
+
+import numpy as np
+
+from qubx import logger
+from qubx.core.basics import Deal, Instrument, Signal, TargetPosition
+from qubx.core.interfaces import IPositionSizer, IStrategyContext, PositionsTracker
+from qubx.core.series import OHLCV, Bar, Quote, Trade
+from qubx.trackers.riskctrl import State, StopTakePositionTracker
+
+
+@dataclass
+class _AdvCtrl:
+    signal: Signal
+    entry: float
+    stop: float
+    entry_bar_time: int
+    is_being_tracked: bool = True
+
+    def is_long(self) -> bool:
+        return self.signal.signal > 0
+
+
+class ImprovedEntryTracker(PositionsTracker):
+    """
+    Advanced entry tracker with additional features like tracking price improvements, reassigning stops, and stop-take functionality.
+
+    Provides the same functionality as StopTakePositionTracker but sends take/stop as limit/stop orders
+    immediately after the tracked position is opened. If new signal is received it should adjust take and stop orders.
+
+    TODO: Need test for ImprovedEntryTracker (AdvancedTrackers)
+    """
+
+    timeframe: str
+    _tracker: StopTakePositionTracker
+    _ohlcs: dict[Instrument, OHLCV]
+    _entries: dict[Instrument, _AdvCtrl]
+
+    def __init__(
+        self,
+        timeframe: str,
+        sizer: IPositionSizer,
+        track_price_improvements: bool = True,
+        reassign_stops: bool = True,  # set stop to signal's bar low / high
+        take_target: float | None = None,
+        stop_risk: float | None = None,
+    ) -> None:
+        super().__init__(sizer)
+        self.track_price_improvements = track_price_improvements
+        self.reassign_stops = reassign_stops
+        self.timeframe = timeframe
+        self._ohlcs = {}
+        self._tracker = StopTakePositionTracker(
+            take_target=take_target, stop_risk=stop_risk, sizer=sizer, risk_controlling_side="broker"
+        )
+        self._entries = {}
+
+    def ohlc(self, instrument: Instrument) -> OHLCV:
+        """
+        We need this for make it works in multiprocessing env
+        """
+        r = self._ohlcs.get(instrument)
+        if r is None:
+            self._ohlcs[instrument] = (r := OHLCV(instrument.symbol, self.timeframe, 3))
+        return r
+
+    def is_active(self, instrument: Instrument) -> bool:
+        if instrument in self._entries:
+            return self._entries[instrument].is_being_tracked
+        return False
+
+    def process_signals(self, ctx: IStrategyContext, signals: list[Signal]) -> list[TargetPosition]:
+        _sgs = []
+        for s in signals:
+            instrument = s.instrument
+            if s.signal == 0:
+                if instrument in self._entries:
+                    logger.debug(
+                        f"[<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: <W>REMOVING FROM</W> got 0 signal - stop entry processing"
+                    )
+                    self._entries.pop(instrument)
+            else:
+                # - buy at signal bar high or sell at signal bar low
+                signal_bar: Bar = self.ohlc(instrument)[0]
+                # - reassign new entry and stop to signal
+                ent_price = signal_bar.high if s.signal > 0 else signal_bar.low
+                stp_price = signal_bar.low if s.signal > 0 else signal_bar.high
+                s.price = ent_price  # new entry
+                if self.reassign_stops or s.stop is None:  # reassign new stop to signal if signal has no stops
+                    s.stop = stp_price
+
+                # - case 1: there's already tracked entry
+                if self._is_entry_tracked_for(instrument):
+                    # - ask tracker to cancel entry stop order
+                    logger.debug(
+                        f"[<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: <Y><k> Cancel entry because new signal </k></Y></g>"
+                    )
+                    _sgs.append(instrument.signal(0, comment=f"{s.comment} - Cancel entry because new signal"))
+
+                # - case 2: position is opened and StopTake tracker tracks it
+                if self._tracker_has_position(instrument):
+                    logger.debug(
+                        f"[<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: <Y><k> Close position because new signal </k></Y>"
+                    )
+                    _sgs.append(instrument.signal(0, comment=f"{s.comment} Close positon because new signal"))
+
+                # - new entry for tracking
+                self._entries[instrument] = _AdvCtrl(s, entry=ent_price, stop=s.stop, entry_bar_time=signal_bar.time)
+
+            _sgs.append(s)
+
+        return self._tracker.process_signals(ctx, _sgs)
+
+    def update(
+        self, ctx: IStrategyContext, instrument: Instrument, update: Quote | Trade | Bar
+    ) -> list[TargetPosition] | TargetPosition:
+        _new_bar = False
+        if isinstance(update, Bar):
+            _new_bar = self.ohlc(instrument).update_by_bar(
+                update.time, update.open, update.high, update.low, upd := update.close, update.volume
+            )
+        elif isinstance(update, Quote):
+            _new_bar = self.ohlc(instrument).update(update.time, upd := update.mid_price(), 0)
+        elif isinstance(update, Trade):
+            _new_bar = self.ohlc(instrument).update(update.time, upd := update.price, update.size)
+        else:
+            raise ValueError(f"Unknown update type: {type(update)}")
+
+        _res = []
+        if self._is_entry_tracked_for(instrument):
+            s = self._entries[instrument]
+            _is_long = s.is_long()
+
+            if (_is_long and upd < s.stop) or (not _is_long and upd > s.stop):
+                logger.debug(
+                    f"[<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: <R><k>CANCELING ENTRY</k></R> : {s.signal} ||| {upd}"
+                )
+                self._entries.pop(instrument)
+                return self._tracker.process_signals(
+                    ctx,
+                    [
+                        instrument.signal(
+                            0, comment=f"Cancel: price {upd} broke entry's {'low' if _is_long else 'high'} at {s.stop}"
+                        )
+                    ],
+                )
+
+            # - if we need to improve entry on new bar
+            if _new_bar and self.track_price_improvements:
+                bar = self.ohlc(instrument)[1]
+                if _is_long and bar.high < s.entry:
+                    logger.debug(
+                        f"[<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: <M><k>IMPROVING LONG ENTRY</k></M> : {s.signal.price} -> {bar.high}"
+                    )
+                    s.signal.price = bar.high
+                    s.signal.take = self.get_new_take_on_improve(ctx, s.signal, bar)
+                    s.entry = bar.high
+                    _res.extend(self._tracker.process_signals(ctx, [s.signal]))
+                elif not _is_long and bar.low > s.entry:
+                    logger.debug(
+                        f"[<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: <M><k>IMPROVING SHORT ENTRY</k></M> : {s.signal.price} -> {bar.low}"
+                    )
+                    s.signal.price = bar.low
+                    s.signal.take = self.get_new_take_on_improve(ctx, s.signal, bar)
+                    s.entry = bar.low
+                    _res.extend(self._tracker.process_signals(ctx, [s.signal]))
+
+        if _tu := self._tracker.update(ctx, instrument, update):
+            _res.extend(_tu)
+        return _res
+
+    def get_new_take_on_improve(self, ctx: IStrategyContext, s: Signal, b: Bar) -> float | None:
+        """
+        What's new take target after improve (remains the same by default)
+        """
+        return s.take
+
+    def _is_entry_tracked_for(self, instrument: Instrument):
+        return instrument in self._entries and (s := self._entries[instrument]).is_being_tracked
+
+    def on_execution_report(self, ctx: IStrategyContext, instrument: Instrument, deal: Deal):
+        self._tracker.on_execution_report(ctx, instrument, deal)
+
+        # - tracker becomes active - so position is open
+        if self._tracker_has_position(instrument):
+            logger.debug(f"[<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: <M><w> Position is open </w></M>")
+            if instrument in self._entries:
+                self._entries[instrument].is_being_tracked = False
+
+        if self._tracker_triggers_risk(instrument):
+            logger.debug(f"[<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: <R><k> Risk triggered </k></R>")
+            if instrument in self._entries:
+                self._entries.pop(instrument)
+
+    def _tracker_has_position(self, instrument: Instrument) -> bool:
+        # TODO: implementation is too StopTakePositionTracker dependent !
+        # TODO: need generic mehod to check if tracker is active / has open positions
+        if instrument in self._tracker.riskctrl._trackings:
+            st = self._tracker.riskctrl._trackings[instrument].status
+            return st == State.OPEN
+        return False
+
+    def _tracker_triggers_risk(self, instrument: Instrument) -> bool:
+        if instrument in self._tracker.riskctrl._trackings:
+            st = self._tracker.riskctrl._trackings[instrument].status
+            return st == State.RISK_TRIGGERED
+        return False
+
+
+class ImprovedEntryTrackerDynamicTake(ImprovedEntryTracker):
+    """
+    Updates take profit target on improved entries
+
+    TODO: Need test for ImprovedEntryTrackerDynamicTake (AdvancedTrackers)
+    """
+
+    risk_reward_ratio: float
+
+    def __init__(
+        self,
+        timeframe: str,
+        sizer: IPositionSizer,
+        risk_reward_ratio: float,
+        track_price_improvements: bool = True,
+        reassign_stops: bool = True,  # set stop to signal's bar low / high
+    ) -> None:
+        super().__init__(timeframe, sizer, track_price_improvements, reassign_stops, None, None)
+        self.risk_reward_ratio = risk_reward_ratio
+
+    def get_new_take_on_improve(self, ctx: IStrategyContext, s: Signal, b: Bar) -> float | None:
+        """
+        Use risk reward ratio to calculate new take target
+        """
+        if (t := s.take) is not None and s.price is not None and s.stop is not None:
+            t = s.price + np.sign(s.signal) * self.risk_reward_ratio * abs(s.price - s.stop)
+        return t

qubx/trackers/composite.py

@@ -0,0 +1,146 @@
+from collections import defaultdict
+from typing import Callable
+
+from qubx.core.basics import Deal, Instrument, Signal, TargetPosition
+from qubx.core.interfaces import IStrategyContext, PositionsTracker
+from qubx.core.series import Bar, OrderBook, Quote, Trade
+
+Targets = list[TargetPosition] | TargetPosition | None
+
+
+class CompositeTracker(PositionsTracker):
+    """
+    Combines multiple trackers. Returns the most conservative target position.
+    """
+
+    def __init__(self, *trackers: PositionsTracker) -> None:
+        self.trackers = trackers
+
+    def process_signals(self, ctx: IStrategyContext, signals: list[Signal]) -> list[TargetPosition]:
+        _index_to_targets: dict[int, Targets] = {
+            index: tracker.process_signals(ctx, signals) for index, tracker in enumerate(self.trackers)
+        }
+        return self._select_min_targets(_index_to_targets)
+
+    def update(
+        self, ctx: IStrategyContext, instrument: Instrument, update: Quote | Trade | Bar | OrderBook
+    ) -> list[TargetPosition]:
+        _index_to_targets: dict[int, Targets] = {
+            index: tracker.update(ctx, instrument, update) for index, tracker in enumerate(self.trackers)
+        }
+        return self._select_min_targets(_index_to_targets)
+
+    def on_execution_report(self, ctx: IStrategyContext, instrument: Instrument, deal: Deal):
+        for tracker in self.trackers:
+            tracker.on_execution_report(ctx, instrument, deal)
+
+    def _select_min_targets(self, tracker_to_targets: dict[int, Targets]) -> list[TargetPosition]:
+        _instrument_to_targets: dict[Instrument, list[TargetPosition]] = defaultdict(list)
+        for targets in tracker_to_targets.values():
+            if isinstance(targets, list):
+                for target in targets:
+                    _instrument_to_targets[target.instrument].append(target)
+            elif isinstance(targets, TargetPosition):
+                _instrument_to_targets[targets.instrument].append(targets)
+
+        _instrument_to_targets = self._process_override_signals(_instrument_to_targets)
+
+        _instr_to_min_target = {
+            symbol: min(targets, key=lambda target: abs(target.target_position_size))
+            for symbol, targets in _instrument_to_targets.items()
+        }
+
+        return list(_instr_to_min_target.values())
+
+    def _process_override_signals(
+        self, instrument_to_targets: dict[Instrument, list[TargetPosition]]
+    ) -> dict[Instrument, list[TargetPosition]]:
+        """
+        Filter out signals that allow override if there is more than one signal for the same symbol.
+        """
+        filt_instr_to_targets = {}
+        for instr, targets in instrument_to_targets.items():
+            if len(targets) == 1 or all(t.signal.options.get("allow_override", False) for t in targets):
+                filt_instr_to_targets[instr] = targets
+                continue
+            filt_instr_to_targets[instr] = [
+                target for target in targets if not target.signal.options.get("allow_override", False)
+            ]
+        return filt_instr_to_targets
+
+
+class ConditionalTracker(PositionsTracker):
+    """
+    Wraps a single tracker. Can be used to add some logic before or after the wrapped tracker.
+    """
+
+    def __init__(self, condition: Callable[[Signal], bool], tracker: PositionsTracker) -> None:
+        self.condition = condition
+        self.tracker = tracker
+
+    def process_signals(self, ctx: IStrategyContext, signals: list[Signal]) -> list[TargetPosition] | TargetPosition:
+        filtered_signals = []
+        for signal in signals:
+            cond = self.condition(signal)
+            if cond:
+                filtered_signals.append(signal)
+            elif self.tracker.is_active(signal.instrument):
+                # This is important for instance if we get an opposite signal
+                # we need to at least close the open position
+                filtered_signals.append(
+                    Signal(
+                        instrument=signal.instrument,
+                        signal=0,
+                        price=signal.price,
+                        stop=signal.stop,
+                        take=signal.take,
+                        reference_price=signal.reference_price,
+                        group=signal.group,
+                        comment=f"Closing opposite signal {signal.signal} {signal.comment}",
+                        options=dict(allow_override=True),
+                    )
+                )
+        return self.tracker.process_signals(ctx, filtered_signals)
+
+    def update(
+        self, ctx: IStrategyContext, instrument: Instrument, update: Quote | Trade | Bar | OrderBook
+    ) -> list[TargetPosition] | TargetPosition:
+        return self.tracker.update(ctx, instrument, update)
+
+    def on_execution_report(self, ctx: IStrategyContext, instrument: Instrument, deal: Deal):
+        self.tracker.on_execution_report(ctx, instrument, deal)
+
+
+class LongTracker(ConditionalTracker):
+    def __init__(self, tracker: PositionsTracker) -> None:
+        super().__init__(self._condition, tracker)
+
+    def _condition(self, signal: Signal) -> bool:
+        return signal.signal > 0
+
+
+class ShortTracker(ConditionalTracker):
+    def __init__(self, tracker: PositionsTracker) -> None:
+        super().__init__(self._condition, tracker)
+
+    def _condition(self, signal: Signal) -> bool:
+        return signal.signal < 0
+
+
+class CompositeTrackerPerSide(CompositeTracker):
+    def __init__(
+        self,
+        trackers: list[PositionsTracker] | None = None,
+        long_trackers: list[PositionsTracker] | None = None,
+        short_trackers: list[PositionsTracker] | None = None,
+    ):
+        if trackers is None and long_trackers is None and short_trackers is None:
+            raise ValueError("At least one of trackers, long_trackers or short_trackers must be provided.")
+        self.trackers = trackers or []
+        self.long_trackers = LongTracker(CompositeTracker(*long_trackers)) if long_trackers else None
+        self.short_trackers = ShortTracker(CompositeTracker(*short_trackers)) if short_trackers else None
+        if self.long_trackers is not None:
+            self.trackers.append(self.long_trackers)
+        if self.short_trackers is not None:
+            self.trackers.append(self.short_trackers)
+        super().__init__(*self.trackers)

qubx/trackers/rebalancers.py

@@ -0,0 +1,129 @@
+from dataclasses import dataclass
+from typing import Dict, Iterable, List, Optional, Set, Tuple, Union
+
+import numpy as np
+import pandas as pd
+
+from qubx import logger
+from qubx.core.basics import Instrument, Position, Signal, TargetPosition
+from qubx.core.interfaces import IPositionGathering, IStrategyContext, PositionsTracker
+from qubx.trackers.sizers import LongShortRatioPortfolioSizer
+
+
+@dataclass
+class Capital:
+    capital: float
+    released_amount: float
+    symbols_to_close: List[str] | None = None
+
+
+class PortfolioRebalancerTracker(PositionsTracker):
+    """
+    Simple portfolio rebalancer based on fixed weights
+    """
+
+    capital_invested: float
+    tolerance: float
+
+    def __init__(
+        self, capital_invested: float, tolerance: float, positions_sizer=LongShortRatioPortfolioSizer()
+    ) -> None:
+        self.capital_invested = capital_invested
+        self.tolerance = tolerance
+        self._positions_sizer = positions_sizer
+
+    def calculate_released_capital(
+        self, ctx: IStrategyContext, instr_to_close: list[Instrument] | None = None
+    ) -> Tuple[float, List[str]]:
+        """
+        Calculate capital that would be released if close positions for provided symbols_to_close list
+        """
+        released_capital_after_close = 0.0
+        closed_symbols = []
+        if instr_to_close is not None:
+            for instr in instr_to_close:
+                p = ctx.positions.get(instr)
+                if p is not None and p.quantity != 0:
+                    released_capital_after_close += p.get_amount_released_funds_after_closing(
+                        to_remain=ctx.get_reserved(p.instrument)
+                    )
+                    closed_symbols.append(instr)
+        return released_capital_after_close, closed_symbols
+
+    def estimate_capital_to_trade(
+        self, ctx: IStrategyContext, instr_to_close: list[Instrument] | None = None
+    ) -> Capital:
+        released_capital = 0.0
+        closed_positions = None
+
+        if instr_to_close is not None:
+            released_capital, closed_positions = self.calculate_released_capital(ctx, instr_to_close)
+
+        cap_to_invest = ctx.get_capital() + released_capital
+        if self.capital_invested > 0:
+            cap_to_invest = min(self.capital_invested, cap_to_invest)
+
+        return Capital(cap_to_invest, released_capital, closed_positions)
+
+    def process_signals(self, ctx: IStrategyContext, signals: List[Signal]) -> List[TargetPosition]:
+        """
+        Portfolio rebalancer - makes rebalancing portfolio based on provided signals.
+        It checks how much funds can be released first and then reallocate it into positions need to be opened.
+        """
+        targets = self._positions_sizer.calculate_target_positions(ctx, signals)
+
+        # - find positions where exposure will be decreased
+        _close_first = []
+        _then_open = []
+        for t in targets:
+            pos = ctx.positions.get(t.instrument)
+            if pos is None:
+                logger.error(f"({self.__class__.__name__}) No position for {t.instrument} instrument !")
+                continue
+
+            _pa, _ta = abs(pos.quantity), abs(t.target_position_size)
+
+            # - ones which decreases exposure
+            if _ta < _pa:
+                reserved = ctx.get_reserved(pos.instrument)
+                # - when we have some reserved amount we should check target position size
+                t.target_position_size = self._correct_target_position(pos.quantity, t.target_position_size, reserved)
+                _close_first.append(t)
+                logger.debug(
+                    f"({self.__class__.__name__}) Decreasing exposure for {t.instrument} from {pos.quantity} -> {t.target_position_size} (reserved: {reserved})"
+                )
+
+            # - ones which increases exposure
+            elif _ta > _pa:
+                _then_open.append(t)
+                logger.debug(
+                    f"({self.__class__.__name__}) Increasing exposure for {t.instrument} from {pos.quantity} -> {t.target_position_size})"
+                )
+
+        return _close_first + _then_open
+
+    def _correct_target_position(self, start_position: float, new_position: float, reserved: float) -> float:
+        """
+        Calcluate target position size considering reserved quantity.
+        """
+        d = np.sign(start_position)
+        qty_to_close = start_position
+
+        if reserved != 0 and start_position != 0 and np.sign(reserved) == d:
+            qty_to_close = max(start_position - reserved, 0) if d > 0 else min(start_position - reserved, 0)
+
+        # - what's max value allowed to close taking in account reserved quantity
+        max_to_close = -d * qty_to_close
+        pos_change = new_position - start_position
+        direction = np.sign(pos_change)
+        prev_direction = np.sign(start_position)
+
+        # - how many shares are closed/open
+        qty_closing = min(abs(start_position), abs(pos_change)) * direction if prev_direction != direction else 0
+        # qty_opening = pos_change if prev_direction == direction else pos_change - qty_closing
+        # print(qty_closing, qty_opening, max_to_close)
+
+        if abs(qty_closing) > abs(max_to_close):
+            return reserved
+
+        return new_position