Qubx 0.5.5__cp311-cp311-manylinux_2_35_x86_64.whl → 0.5.6__cp311-cp311-manylinux_2_35_x86_64.whl

qubx/backtester/account.py

@@ -48,14 +48,15 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
         if self._fill_stop_order_at_price:
             logger.info(f"[<y>{self.__class__.__name__}</y>] :: emulates stop orders executions at exact price")
 
-    def get_orders(self, instrument: Instrument | None = None) -> list[Order]:
+    def get_orders(self, instrument: Instrument | None = None) -> dict[str, Order]:
         if instrument is not None:
             ome = self.ome.get(instrument)
             if ome is None:
                 raise ValueError(f"ExchangeService:get_orders :: No OME configured for '{instrument}'!")
-            return ome.get_open_orders()
 
-        return [o for ome in self.ome.values() for o in ome.get_open_orders()]
+            return {o.id: o for o in ome.get_open_orders()}
+
+        return {o.id: o for ome in self.ome.values() for o in ome.get_open_orders()}
 
     def get_position(self, instrument: Instrument) -> Position:
         if instrument in self.positions:

qubx/backtester/management.py

@@ -60,7 +60,20 @@ class BacktestsResultsManager:
 
         return self
 
-    def load(self, name: str | int | list[int] | list[str]) -> TradingSessionResult | list[TradingSessionResult]:
+    def __getitem__(
+        self, name: str | int | list[int] | list[str] | slice
+    ) -> TradingSessionResult | list[TradingSessionResult]:
+        return self.load(name)
+
+    def load(
+        self, name: str | int | list[int] | list[str] | slice
+    ) -> TradingSessionResult | list[TradingSessionResult]:
+        match name:
+            case list():
+                return [self.load(i) for i in name]
+            case slice():
+                return [self.load(i) for i in range(name.start, name.stop, name.step if name.step else 1)]
+
         for info in self.results.values():
             match name:
                 case int():
@@ -69,12 +82,80 @@ class BacktestsResultsManager:
                 case str():
                     if info.get("name", "") == name:
                         return TradingSessionResult.from_file(info["path"])
-                case list():
-                    return [self.load(i) for i in name]
-
         raise ValueError(f"No result found for {name}")
 
-    def list(self, regex: str = "", with_metrics=False, params=False):
+    def delete(self, name: str | int | list[int] | list[str] | slice):
+        def _del_idx(idx):
+            for info in self.results.values():
+                if info.get("idx", -1) == idx:
+                    Path(info["path"]).unlink()
+                    return info.get("name", idx)
+            return None
+
+        match name:
+            case str():
+                nms = [_del_idx(i) for i in self._find_indices(name)]
+                self.reload()
+                print(f" -> Deleted {red(', '.join(nms))} ...")
+                return
+
+            case list():
+                nms = [_del_idx(i) for i in name]
+                self.reload()
+                print(f" -> Deleted {red(', '.join(nms))} ...")
+                return
+
+            case slice():
+                nms = [_del_idx(i) for i in range(name.start, name.stop, name.step if name.step else 1)]
+                self.reload()
+                print(f" -> Deleted {red(', '.join(nms))} ...")
+                return
+
+        for info in self.results.values():
+            match name:
+                case int():
+                    if info.get("idx", -1) == name:
+                        Path(info["path"]).unlink()
+                        print(f" -> Deleted {red(info.get('name', name))} ...")
+                        self.reload()
+                        return
+                case str():
+                    if info.get("name", "") == name:
+                        Path(info["path"]).unlink()
+                        print(f" -> Deleted {red(info.get('name', name))} ...")
+                        self.reload()
+                        return
+        print(f" -> No results found for {red(name)} !")
+
+    def _find_indices(self, regex: str):
+        for n in sorted(self.results.keys()):
+            info = self.results[n]
+            s_cls = info.get("strategy_class", "").split(".")[-1]
+
+            try:
+                if not re.match(regex, n, re.IGNORECASE):
+                    if not re.match(regex, s_cls, re.IGNORECASE):
+                        continue
+            except Exception:
+                if regex.lower() != n.lower() and regex.lower() != s_cls.lower():
+                    continue
+
+            yield info.get("idx", -1)
+
+    def list(self, regex: str = "", with_metrics=True, params=False, as_table=False):
+        """List backtesting results with optional filtering and formatting.
+
+        Args:
+            - regex (str, optional): Regular expression pattern to filter results by strategy name or class. Defaults to "".
+            - with_metrics (bool, optional): Whether to include performance metrics in output. Defaults to True.
+            - params (bool, optional): Whether to display strategy parameters. Defaults to False.
+            - as_table (bool, optional): Return results as a pandas DataFrame instead of printing. Defaults to False.
+
+        Returns:
+            - Optional[pd.DataFrame]: If as_table=True, returns a DataFrame containing the results sorted by creation time.
+            - Otherwise prints formatted results to console.
+        """
+        _t_rep = []
         for n in sorted(self.results.keys()):
             info = self.results[n]
             s_cls = info.get("strategy_class", "").split(".")[-1]
@@ -89,12 +170,17 @@ class BacktestsResultsManager:
             start = pd.Timestamp(info.get("start", "")).round("1s")
             stop = pd.Timestamp(info.get("stop", "")).round("1s")
             dscr = info.get("description", "")
-            _s = f"{yellow(str(info.get('idx')))} - {red(name)} ::: {magenta(pd.Timestamp(info.get('creation_time', '')).round('1s'))} by {cyan(info.get('author', ''))}"
+            created = pd.Timestamp(info.get("creation_time", "")).round("1s")
+            metrics = info.get("performance", {})
+            author = info.get("author", "")
+            _s = f"{yellow(str(info.get('idx')))} - {red(name)} ::: {magenta(created)} by {cyan(author)}"
 
+            _one_line_dscr = ""
             if dscr:
                 dscr = dscr.split("\n")
                 for _d in dscr:
                     _s += f"\n\t{magenta('# ' + _d)}"
+                    _one_line_dscr += " " + _d
 
             _s += f"\n\tstrategy: {green(s_cls)}"
             _s += f"\n\tinterval: {blue(start)} - {blue(stop)}"
@@ -110,32 +196,42 @@ class BacktestsResultsManager:
                     justify="left",
                 ).split("\n"):
                     _s += f"\n\t  |  {yellow(i)}"
-            print(_s)
+
+            if not as_table:
+                print(_s)
 
             if with_metrics:
-                r = TradingSessionResult.from_file(info["path"])
-                metric = _pfl_metrics_prepare(r, True, 365)
-                _m_repr = str(metric[0][["Gain", "Cagr", "Sharpe", "Max dd pct", "Qr", "Fees"]].round(3)).split("\n")[
-                    :-1
-                ]
-                for i in _m_repr:
-                    print("\t " + cyan(i))
-            print()
-
-    def delete(self, name: str | int):
-        print(red(f" -> Danger zone - you are about to delete {name} ..."))
-        for info in self.results.values():
-            match name:
-                case int():
-                    if info.get("idx", -1) == name:
-                        Path(info["path"]).unlink()
-                        print(f" -> Deleted {red(name)} ...")
-                        self.reload()
-                        return
-                case str():
-                    if info.get("name", "") == name:
-                        Path(info["path"]).unlink()
-                        print(f" -> Deleted {red(name)} ...")
-                        self.reload()
-                        return
-        print(f" -> No results found for {red(name)} !")
+                _m_repr = (
+                    pd.DataFrame.from_dict(metrics, orient="index")
+                    .T[["gain", "cagr", "sharpe", "qr", "max_dd_pct", "mdd_usd", "fees", "execs"]]
+                    .astype(float)
+                )
+                _m_repr = _m_repr.round(3).to_string(index=False)
+                _h, _v = _m_repr.split("\n")
+                if not as_table:
+                    print("\t " + red(_h))
+                    print("\t " + cyan(_v))
+
+            if not as_table:
+                print()
+            else:
+                metrics = {
+                    m: round(v, 3)
+                    for m, v in metrics.items()
+                    if m in ["gain", "cagr", "sharpe", "qr", "max_dd_pct", "mdd_usd", "fees", "execs"]
+                }
+                _t_rep.append(
+                    {"Index": info.get("idx", ""), "Strategy": name}
+                    | metrics
+                    | {
+                        "start": start,
+                        "stop": stop,
+                        "Created": created,
+                        "Author": author,
+                        "Description": _one_line_dscr,
+                    },
+                )
+
+        if as_table:
+            _df = pd.DataFrame.from_records(_t_rep, index="Index")
+            return _df.sort_values(by="Created", ascending=False)

qubx/core/context.py

@@ -34,6 +34,7 @@ from qubx.core.interfaces import (
     ITradingManager,
     IUniverseManager,
     PositionsTracker,
+    RemovalPolicy,
 )
 from qubx.core.loggers import StrategyLogging
 from qubx.data.readers import DataReader
@@ -144,6 +145,7 @@ class StrategyContext(IStrategyContext):
             account=self.account,
             position_tracker=__position_tracker,
             position_gathering=__position_gathering,
+            universe_manager=self._universe_manager,
             cache=self._cache,
             scheduler=self._scheduler,
             is_simulation=self._data_provider.is_simulation,
@@ -325,8 +327,10 @@ class StrategyContext(IStrategyContext):
         return self._trading_manager.cancel_orders(instrument)
 
     # IUniverseManager delegation
-    def set_universe(self, instruments: list[Instrument], skip_callback: bool = False):
-        return self._universe_manager.set_universe(instruments, skip_callback)
+    def set_universe(
+        self, instruments: list[Instrument], skip_callback: bool = False, if_has_position_then: RemovalPolicy = "close"
+    ):
+        return self._universe_manager.set_universe(instruments, skip_callback, if_has_position_then)
 
     def add_instruments(self, instruments: list[Instrument]):
         return self._universe_manager.add_instruments(instruments)

qubx/core/helpers.py

@@ -14,7 +14,7 @@ from croniter import croniter
 from qubx import logger
 from qubx.core.basics import SW, CtrlChannel, DataType, Instrument, Timestamped
 from qubx.core.series import OHLCV, Bar, OrderBook, Quote, Trade
-from qubx.utils.time import convert_seconds_to_str, convert_tf_str_td64
+from qubx.utils.time import convert_seconds_to_str, convert_tf_str_td64, interval_to_cron
 
 
 class CachedMarketDataHolder:
@@ -204,7 +204,7 @@ def _make_shift(_b, _w, _d, _h, _m, _s):
 
     # return AS_TD(f'{_b*4}W') + AS_TD(f'{_w}W') + AS_TD(f'{_d}D') + AS_TD(f'{_h}h') + AS_TD(f'{_m}Min') + AS_TD(f'{_s}Sec')
     for t in [
-        AS_TD(f"{_b*4}W"),
+        AS_TD(f"{_b * 4}W"),
         AS_TD(f"{_w}W"),
         AS_TD(f"{_d}D"),
         AS_TD(f"{_h}h"),
@@ -218,12 +218,12 @@ def _make_shift(_b, _w, _d, _h, _m, _s):
     return P, N
 
 
-def _parse_schedule_spec(schedule: str) -> Dict[str, str]:
+def _parse_schedule_spec(schedule: str) -> dict[str, str]:
     m = SPEC_REGEX.match(schedule)
     return {k: v for k, v in m.groupdict().items() if v} if m else {}
 
 
-def process_schedule_spec(spec_str: str | None) -> Dict[str, Any]:
+def process_schedule_spec(spec_str: str | None) -> dict[str, Any]:
     AS_INT = lambda d, k: int(d.get(k, 0))  # noqa: E731
     S = lambda s: [x for x in re.split(r"[, ]", s) if x]  # noqa: E731
     config = {}
@@ -246,10 +246,16 @@ def process_schedule_spec(spec_str: str | None) -> Dict[str, Any]:
 
     match _T:
         case "cron":
-            if not _S or croniter.is_valid(_S):
-                config = dict(type="cron", schedule=_S, spec=_S)
-            else:
-                raise ValueError(f"Wrong specification for cron type: {_S}")
+            if not _S:
+                raise ValueError(f"Empty specification for cron: {spec_str}")
+
+            if not croniter.is_valid(_S):
+                _S = interval_to_cron(_S)
+
+                if not croniter.is_valid(_S):
+                    raise ValueError(f"Wrong specification for cron: {spec_str}")
+
+            config = dict(type="cron", schedule=_S, spec=_S)
 
         case "time":
             for t in _t:
@@ -265,13 +271,20 @@ def process_schedule_spec(spec_str: str | None) -> Dict[str, Any]:
                     if croniter.is_valid(_S):
                         config = dict(type="cron", schedule=_S, spec=_S)
                     else:
-                        if _has_intervals:
-                            _F = (
-                                convert_seconds_to_str(int(_s_pos.as_unit("s").to_timedelta64().item().total_seconds()))
-                                if not _F
-                                else _F
-                            )
-                            config = dict(type="bar", schedule=None, timeframe=_F, delay=_s_neg, spec=_S)
+                        # - try convert to cron
+                        _S = interval_to_cron(_S)
+                        if croniter.is_valid(_S):
+                            config = dict(type="cron", schedule=_S, spec=_S)
+                        else:
+                            if _has_intervals:
+                                _F = (
+                                    convert_seconds_to_str(
+                                        int(_s_pos.as_unit("s").to_timedelta64().item().total_seconds())
+                                    )
+                                    if not _F
+                                    else _F
+                                )
+                                config = dict(type="bar", schedule=None, timeframe=_F, delay=_s_neg, spec=_S)
         case _:
             config = dict(type=_T, schedule=None, timeframe=_F, delay=_shift, spec=_S)
 
@@ -348,6 +361,7 @@ class BasicScheduler:
             # - update next nearest time
             self._next_times[event] = next_time
             self._next_nearest_time = np.datetime64(int(min(self._next_times.values()) * 1000000000), "ns")
+            # logger.debug(f" >>> ({event}) task is scheduled at {self._next_nearest_time}")
 
             return True
         logger.debug(f"({event}) task is not scheduled")

qubx/core/interfaces.py

@@ -10,7 +10,7 @@ This module includes:
 """
 
 import traceback
-from typing import Any, Dict, List, Set, Tuple
+from typing import Any, Dict, List, Literal, Set, Tuple
 
 import numpy as np
 import pandas as pd
@@ -36,6 +36,8 @@ from qubx.core.basics import (
 from qubx.core.helpers import set_parameters_to_object
 from qubx.core.series import OHLCV, Bar, Quote
 
+RemovalPolicy = Literal["close", "wait_for_close", "wait_for_change"]
+
 
 class IAccountViewer:
     account_id: str
@@ -568,11 +570,18 @@ class ITradingManager:
 class IUniverseManager:
     """Manages universe updates."""
 
-    def set_universe(self, instruments: list[Instrument], skip_callback: bool = False):
+    def set_universe(
+        self, instruments: list[Instrument], skip_callback: bool = False, if_has_position_then: RemovalPolicy = "close"
+    ):
         """Set the trading universe.
 
         Args:
             instruments: List of instruments in the universe
+            skip_callback: Skip callback to the strategy
+            if_has_position_then: What to do if the instrument has a position
+                - “close” (default) - close position immediatelly and remove (unsubscribe) instrument from strategy
+                - “wait_for_close” - keep instrument and it’s position until it’s closed from strategy (or risk management), then remove instrument from strategy
+                - “wait_for_change” - keep instrument and position until strategy would try to change it - then close position and remove instrument
         """
         ...
 
@@ -584,11 +593,15 @@ class IUniverseManager:
         """
         ...
 
-    def remove_instruments(self, instruments: list[Instrument]):
+    def remove_instruments(self, instruments: list[Instrument], if_has_position_then: RemovalPolicy = "close"):
         """Remove instruments from the trading universe.
 
         Args:
             instruments: List of instruments to remove
+            if_has_position_then: What to do if the instrument has a position
+                - “close” (default) - close position immediatelly and remove (unsubscribe) instrument from strategy
+                - “wait_for_close” - keep instrument and it’s position until it’s closed from strategy (or risk management), then remove instrument from strategy
+                - “wait_for_change” - keep instrument and position until strategy would try to change it - then close position and remove instrument
         """
         ...
 
@@ -599,6 +612,19 @@ class IUniverseManager:
         """
         ...
 
+    def on_alter_position(self, instrument: Instrument) -> None:
+        """
+        Called when the position of an instrument changes.
+        It can be used for postponed unsubscribed events
+        """
+        ...
+
+    def is_trading_allowed(self, instrument: Instrument) -> bool:
+        """
+        Check if trading is allowed for an instrument because of the instrument's trading policy.
+        """
+        ...
+
 
 class ISubscriptionManager:
     """Manages subscriptions."""

qubx/core/mixins/processing.py

@@ -28,6 +28,7 @@ from qubx.core.interfaces import (
     IStrategyContext,
     ISubscriptionManager,
     ITimeProvider,
+    IUniverseManager,
     PositionsTracker,
 )
 from qubx.core.loggers import StrategyLogging
@@ -48,6 +49,7 @@ class ProcessingManager(IProcessingManager):
     _position_gathering: IPositionGathering
     _cache: CachedMarketDataHolder
     _scheduler: BasicScheduler
+    _universe_manager: IUniverseManager
 
     _handlers: dict[str, Callable[["ProcessingManager", Instrument, str, Any], TriggerEvent | None]]
     _strategy_name: str
@@ -72,6 +74,7 @@ class ProcessingManager(IProcessingManager):
         account: IAccountProcessor,
         position_tracker: PositionsTracker,
         position_gathering: IPositionGathering,
+        universe_manager: IUniverseManager,
         cache: CachedMarketDataHolder,
         scheduler: BasicScheduler,
         is_simulation: bool,
@@ -86,6 +89,7 @@ class ProcessingManager(IProcessingManager):
         self._is_simulation = is_simulation
         self._position_gathering = position_gathering
         self._position_tracker = position_tracker
+        self._universe_manager = universe_manager
         self._cache = cache
         self._scheduler = scheduler
 
@@ -100,7 +104,7 @@ class ProcessingManager(IProcessingManager):
 
     def set_fit_schedule(self, schedule: str) -> None:
         rule = process_schedule_spec(schedule)
-        if rule["type"] != "cron":
+        if rule.get("type") != "cron":
             raise ValueError("Only cron type is supported for fit schedule")
         self._scheduler.schedule_event(rule["schedule"], "fit")
 
@@ -228,8 +232,13 @@ class ProcessingManager(IProcessingManager):
     ) -> list[TargetPosition]:
         if target_positions is None:
             return []
+
         if isinstance(target_positions, TargetPosition):
             target_positions = [target_positions]
+
+        # - check if trading is allowed for each target position
+        target_positions = [t for t in target_positions if self._universe_manager.is_trading_allowed(t.instrument)]
+
         self._logging.save_signals_targets(target_positions)
         return target_positions
 
@@ -394,14 +403,17 @@ class ProcessingManager(IProcessingManager):
         return order
 
     @SW.watch("StrategyContext")
-    def _handle_deals(self, instrument: Instrument, event_type: str, deals: list[Deal]) -> TriggerEvent | None:
-        self._account.process_deals(instrument, deals)
-        self._logging.save_deals(instrument, deals)
+    def _handle_deals(self, instrument: Instrument | None, event_type: str, deals: list[Deal]) -> TriggerEvent | None:
         if instrument is None:
             logger.debug(
                 f"[<y>{self.__class__.__name__}</y>] :: Execution report for unknown instrument <r>{instrument}</r>"
             )
-            return
+            return None
+
+        # - process deals only for subscribed instruments
+        self._account.process_deals(instrument, deals)
+        self._logging.save_deals(instrument, deals)
+
         for d in deals:
             # - notify position gatherer and tracker
             self._position_gathering.on_execution_report(self._context, instrument, d)
@@ -409,4 +421,8 @@ class ProcessingManager(IProcessingManager):
             logger.debug(
                 f"[<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: executed <r>{d.order_id}</r> | {d.amount} @ {d.price}"
             )
+
+        # - notify universe manager about position change
+        self._universe_manager.on_alter_position(instrument)
+
         return None

qubx/core/mixins/universe.py

@@ -1,4 +1,6 @@
-from qubx.core.basics import DataType, Instrument, TargetPosition
+from typing import Literal
+
+from qubx.core.basics import DataType, Instrument, Position, TargetPosition
 from qubx.core.helpers import CachedMarketDataHolder
 from qubx.core.interfaces import (
     IAccountProcessor,
@@ -11,6 +13,7 @@ from qubx.core.interfaces import (
     ITimeProvider,
     ITradingManager,
     IUniverseManager,
+    RemovalPolicy,
 )
 from qubx.core.loggers import StrategyLogging
 
@@ -27,6 +30,7 @@ class UniverseManager(IUniverseManager):
     _time_provider: ITimeProvider
     _account: IAccountProcessor
     _position_gathering: IPositionGathering
+    _removal_queue: dict[Instrument, tuple[RemovalPolicy, bool]]
 
     def __init__(
         self,
@@ -54,56 +58,132 @@ class UniverseManager(IUniverseManager):
         self._account = account
         self._position_gathering = position_gathering
         self._instruments = []
+        self._removal_queue = {}
+
+    def _has_position(self, instrument: Instrument) -> bool:
+        return (
+            instrument in self._account.positions
+            and abs(self._account.positions[instrument].quantity) > instrument.min_size
+        )
+
+    def set_universe(
+        self,
+        instruments: list[Instrument],
+        skip_callback: bool = False,
+        if_has_position_then: RemovalPolicy = "close",
+    ) -> None:
+        assert if_has_position_then in (
+            "close",
+            "wait_for_close",
+            "wait_for_change",
+        ), "Invalid if_has_position_then policy"
 
-    def set_universe(self, instruments: list[Instrument], skip_callback: bool = False) -> None:
         new_set = set(instruments)
         prev_set = set(self._instruments)
-        rm_instr = list(prev_set - new_set)
-        add_instr = list(new_set - prev_set)
 
-        self.__add_instruments(add_instr)
-        self.__remove_instruments(rm_instr)
+        # - determine instruments to remove depending on if_has_position_then policy
+        may_be_removed = list(prev_set - new_set)
+
+        # - split instruments into removable and keepable
+        to_remove, to_keep = self._get_what_can_be_removed_or_kept(may_be_removed, skip_callback, if_has_position_then)
+
+        to_add = list(new_set - prev_set)
+        self.__do_add_instruments(to_add)
+        self.__do_remove_instruments(to_remove)
+
+        # - cleanup removal queue
+        self.__cleanup_removal_queue(instruments)
 
-        if not skip_callback and (add_instr or rm_instr):
-            self._strategy.on_universe_change(self._context, add_instr, rm_instr)
+        if not skip_callback and (to_add or to_remove):
+            self._strategy.on_universe_change(self._context, to_add, to_remove)
 
         self._subscription_manager.commit()  # apply pending changes
 
         # set new instruments
         self._instruments.clear()
         self._instruments.extend(instruments)
+        self._instruments.extend(to_keep)
+
+    def _get_what_can_be_removed_or_kept(
+        self, may_be_removed: list[Instrument], skip_callback: bool, if_has_position_then: RemovalPolicy
+    ) -> tuple[list[Instrument], list[Instrument]]:
+        immediately_close = if_has_position_then == "close"
+        to_remove, to_keep = [], []
+        for instr in may_be_removed:
+            if immediately_close:
+                to_remove.append(instr)
+            else:
+                if self._has_position(instr):
+                    self._removal_queue[instr] = (if_has_position_then, skip_callback)
+                    to_keep.append(instr)
+        return to_remove, to_keep
+
+    def __cleanup_removal_queue(self, instruments: list[Instrument]):
+        for instr in instruments:
+            # - if it's still in the removal queue, remove it
+            if instr in self._removal_queue:
+                self._removal_queue.pop(instr)
 
     def add_instruments(self, instruments: list[Instrument]):
-        self.__add_instruments(instruments)
+        self.__do_add_instruments(instruments)
+        self.__cleanup_removal_queue(instruments)
         self._strategy.on_universe_change(self._context, instruments, [])
         self._subscription_manager.commit()
         self._instruments.extend(instruments)
 
-    def remove_instruments(self, instruments: list[Instrument]):
-        self.__remove_instruments(instruments)
-        self._strategy.on_universe_change(self._context, [], instruments)
+    def remove_instruments(
+        self,
+        instruments: list[Instrument],
+        if_has_position_then: RemovalPolicy = "close",
+    ):
+        assert if_has_position_then in (
+            "close",
+            "wait_for_close",
+            "wait_for_change",
+        ), "Invalid if_has_position_then policy"
+
+        # - split instruments into removable and keepable
+        to_remove, to_keep = self._get_what_can_be_removed_or_kept(instruments, False, if_has_position_then)
+
+        # - remove ones that can be removed immediately
+        self.__do_remove_instruments(to_remove)
+        self._strategy.on_universe_change(self._context, [], to_remove)
         self._subscription_manager.commit()
-        self._instruments = list(set(self._instruments) - set(instruments))
+
+        # - update instruments list
+        self._instruments = list(set(self._instruments) - set(to_remove))
+        self._instruments.extend(to_keep)
 
     @property
     def instruments(self) -> list[Instrument]:
         return self._instruments
 
-    def __remove_instruments(self, instruments: list[Instrument]) -> None:
+    def __do_remove_instruments(self, instruments: list[Instrument]):
         """
         Remove symbols from universe. Steps:
-        - close all open positions
-        - unsubscribe from market data
-        - remove from data cache
+        - [v] cancel all open orders
+        - [v] close all open positions
+        - [v] unsubscribe from market data
+        - [v] remove from data cache
 
         We are still keeping the symbols in the positions dictionary.
         """
+        if not instruments:
+            return
+
+        # - preprocess instruments and cancel all open orders
+        for instr in instruments:
+            # - remove instrument from the removal queue if it's there
+            self._removal_queue.pop(instr, None)
+
+            # - cancel all open orders
+            self._trading_manager.cancel_orders(instr)
+
         # - close all open positions
         exit_targets = [
             TargetPosition.zero(self._context, instr.signal(0, group="Universe", comment="Universe change"))
             for instr in instruments
-            if instr.symbol in self._account.positions
-            and abs(self._account.positions[instr.symbol].quantity) > instr.min_size
+            if self._has_position(instr)
         ]
         self._position_gathering.alter_positions(self._context, exit_targets)
 
@@ -121,11 +201,11 @@ class UniverseManager(IUniverseManager):
         for instr in instruments:
             self._cache.remove(instr)
 
-    def __add_instruments(self, instruments: list[Instrument]) -> None:
+    def __do_add_instruments(self, instruments: list[Instrument]) -> None:
         # - create positions for instruments
         self._create_and_update_positions(instruments)
 
-        # - get actual positions from exchange
+        # - initialize ohlcv for new instruments
         for instr in instruments:
             self._cache.init_ohlcv(instr)
 
@@ -153,3 +233,40 @@ class UniverseManager(IUniverseManager):
             #     instrument._aux_instrument = aux
             #     instruments.append(aux)
             #     _ = self._trading_service.get_position(aux)
+
+    def on_alter_position(self, instrument: Instrument) -> None:
+        """
+        Called when the position of an instrument changes.
+        It can be used for postponed unsubscribed events
+        """
+        # - check if need to remove instrument from the universe
+        if instrument in self._removal_queue:
+            _, skip_callback = self._removal_queue[instrument]
+
+            # - if no position, remove instrument from the universe
+            if not self._has_position(instrument):
+                self.__do_remove_instruments([instrument])
+
+                if not skip_callback:
+                    self._strategy.on_universe_change(self._context, [], [instrument])
+
+                # - commit changes and remove instrument from the universe
+                self._subscription_manager.commit()
+                self._instruments.remove(instrument)
+
+    def is_trading_allowed(self, instrument: Instrument) -> bool:
+        if instrument in self._removal_queue:
+            policy, skip_callback = self._removal_queue[instrument]
+
+            if policy == "wait_for_change":
+                self.__do_remove_instruments([instrument])
+
+                if not skip_callback:
+                    self._strategy.on_universe_change(self._context, [], [instrument])
+
+                # - commit changes and remove instrument from the universe
+                self._subscription_manager.commit()
+                self._instruments.remove(instrument)
+                return False
+
+        return True

qubx/utils/runner/runner.py

@@ -405,7 +405,7 @@ def simulate_strategy(
 
         experiments = variate(stg_cls, **(cfg.parameters | cfg.variate), conditions=conditions)
         experiments = {f"{simulation_name}.{_v_id}.[{k}]": v for k, v in experiments.items()}
-        print(f"Variation is enabled. There are {len(experiments)} simualtions to run.")
+        print(f"Parameters variation is configured. There are {len(experiments)} simulations to run.")
         _n_jobs = -1
     else:
         strategy = stg_cls(**cfg.parameters)
@@ -430,6 +430,15 @@ def simulate_strategy(
         sim_params["stop"] = stop
         logger.info(f"Stop date set to {stop}")
 
+    # - check for aux_data parameter
+    if "aux_data" in sim_params:
+        aux_data = sim_params.pop("aux_data")
+        if aux_data is not None:
+            try:
+                sim_params["aux_data"] = eval(aux_data)
+            except Exception as e:
+                raise ValueError(f"Invalid aux_data parameter: {aux_data}") from e
+
     # - run simulation
     print(f" > Run simulation for [{red(simulation_name)}] ::: {sim_params['start']} - {sim_params['stop']}")
     sim_params["n_jobs"] = sim_params.get("n_jobs", _n_jobs)

qubx/utils/time.py

@@ -225,3 +225,88 @@ def timedelta_to_crontab(td: pd.Timedelta) -> str:
         return f"* * * * * */{seconds}"
 
     raise ValueError("Timedelta must specify a non-zero period of days, hours, minutes or seconds")
+
+
+def interval_to_cron(inv: str) -> str:
+    """
+    Convert a custom schedule format to a cron expression.
+
+    Args:
+        inv (str): Custom schedule format string. Can be either:
+            - A pandas Timedelta string (e.g. "4h", "2d", "1d12h")
+            - A custom schedule format "<interval>@<time>" where:
+                interval: Optional number + unit (Q=quarter, M=month, Y=year, D=day, SUN=Sunday, MON=Monday, etc.)
+                time: HH:MM or HH:MM:SS
+
+    Returns:
+        str: Cron expression
+
+    Examples:
+        >>> interval_to_cron("4h")  # Pandas Timedelta
+        '0 */4 * * *'
+        >>> interval_to_cron("2d")  # Pandas Timedelta
+        '59 23 */2 * *'
+        >>> interval_to_cron("@10:30")  # Daily at 10:30
+        '30 10 * * *'
+        >>> interval_to_cron("1M@15:00")  # Monthly at 15:00
+        '0 15 1 */1 * *'
+        >>> interval_to_cron("2Q@09:30:15")  # Every 2 quarters at 9:30:15
+        '30 9 1 */6 * 15'
+        >>> interval_to_cron("Y@00:00")  # Annually at midnight
+        '0 0 1 1 * *'
+        >>> interval_to_cron("TUE @ 23:59")
+        '59 23 * * 2'
+    """
+    # - first try parsing as pandas Timedelta
+    try:
+        _td_inv = pd.Timedelta(inv)
+        return timedelta_to_crontab(_td_inv)
+    except Exception:
+        pass
+
+    # - parse custom schedule format
+    try:
+        # - split into interval and time parts
+        interval, time = inv.split("@")
+        interval = interval.strip()
+        time = time.strip()
+
+        # - parse time
+        time_parts = time.split(":")
+        if len(time_parts) == 2:
+            hour, minute = time_parts
+            second = "0"
+        elif len(time_parts) == 3:
+            hour, minute, second = time_parts
+        else:
+            raise ValueError("Invalid time format")
+
+        # - parse interval
+        if not interval:  # Default to 1 day if no interval specified
+            return f"{minute} {hour} * * * {second}"
+
+        match = re.match(r"^(\d+)?([A-Za-z]+)$", interval)
+        if not match:
+            raise ValueError(f"Invalid interval format: {interval}")
+        number = match.group(1) or "1"
+        unit = match.group(2).upper()
+
+        dow = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"]
+
+        # - convert to cron expression
+        match unit:
+            case "Q":  # Quarter
+                return f"{minute} {hour} 1 */{3 * int(number)} * {second}"
+            case "M":  # Month
+                return f"{minute} {hour} 1 */{number} * {second}"
+            case "Y":  # Year
+                return f"{minute} {hour} 1 1 * {second}"
+            case "SUN" | "MON" | "TUE" | "WED" | "THU" | "FRI" | "SAT":  # Day of Week
+                return f"{minute} {hour} * * {dow.index(unit)} {second}"
+            case "D":  # Day
+                return f"{minute} {hour} */{number} * * {second}"
+            case _:
+                raise ValueError(f"Invalid interval unit: {unit}")
+
+    except Exception as e:
+        raise ValueError(f"Invalid schedule format: {inv}") from e

{qubx-0.5.5.dist-info → qubx-0.5.6.dist-info}/METADATA

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

{qubx-0.5.5.dist-info → qubx-0.5.6.dist-info}/RECORD

@@ -1,10 +1,10 @@
 qubx/__init__.py,sha256=pfxwsCedCQJRMyLurWZGccVlUytAPNonVRa_cyBSbmw,7145
 qubx/_nb_magic.py,sha256=35HLYGGuP0_hiSZ-onCyZQJXTnGuDMueYQATZPtAYVg,2801
 qubx/backtester/__init__.py,sha256=2VP3RCc5y542IBYynV33rsZ4PD-zG-lijTbD3udD9Sg,114
-qubx/backtester/account.py,sha256=5lnLJq4i12vb8F2R-vuyXUs_UbapFSxLTTAL2IT1qGo,5807
+qubx/backtester/account.py,sha256=VBFiUMS3So1wVJCmQ3NtZ6Px1zMyi9hVjiq5Cn7sfm8,5838
 qubx/backtester/broker.py,sha256=9Xm85OyLf-1hc2G1CcIPnatTMvFcdUTZSClJWc4quKU,2759
 qubx/backtester/data.py,sha256=5t3e8PHPf2ZJ7ZsswvyOznyJx8PtqaOzaAy85aIENU0,11826
-qubx/backtester/management.py,sha256=qprAmiyu23bhtC1UEU45V0GpfrMzZSMQ8pcfwvu3iUo,5510
+qubx/backtester/management.py,sha256=zO9KZXxzEEZNHaEuLH3Yf-faNQ75idovFh0SyhqVb8U,9290
 qubx/backtester/ome.py,sha256=zveRUXBKnjR3fqKD44NOKpJPAgPDjMXzdwRTFTbXOCw,11066
 qubx/backtester/optimization.py,sha256=Bl-7zLpmpnRnc12iPxxQeKjITsoUegis5DgipQqF_4o,7618
 qubx/backtester/simulated_data.py,sha256=MVAjmj6ocXr8gPMXDfFfYljI7HVnShTUnAaayl7TbG4,22183
@@ -23,24 +23,24 @@ qubx/connectors/ccxt/utils.py,sha256=jxNd5f8_BjwP50L18ATX2kqyPRg-GAnca25FhCGGvzA
 qubx/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubx/core/account.py,sha256=0tH4-RNiZFNhmh1OBgQUlACbXNhxyeZore8bFWAFexw,10215
 qubx/core/basics.py,sha256=pFfNYRGroQ1K0x54oZC7503sJA5r1GlENKfKq4PFIdM,27789
-qubx/core/context.py,sha256=IGNLwS28OUdNjbeWyugy_e0ut-XwnXwpd791LKjyBFc,15461
+qubx/core/context.py,sha256=nOzB_FFzGwjtYo7o8lwBEnJASr1fkd9B_Cc3SCcy7Kw,15616
 qubx/core/exceptions.py,sha256=Jidp6v8rF6bCGB4SDNPt5CMHltkd9tbVkHzOvM29KdU,477
-qubx/core/helpers.py,sha256=h9sFpl_o0SZuringIik0oDWBO07graHDKvB9tvSLQts,17058
-qubx/core/interfaces.py,sha256=kkwf3Zy0LjKc2-WiZQ9dAR4OrEFVWAyI0j7bBo48O70,32663
+qubx/core/helpers.py,sha256=7nhO-CgleU6RTXpSwCdMwb0ZwLCYi5hJWnag8kfFDXo,17701
+qubx/core/interfaces.py,sha256=giiZAZpNsj5cUCEJMRv9IY1LKqTkbKS41xYksAI24uE,34369
 qubx/core/loggers.py,sha256=ytUJh7k2npS8XY3chM7p-j32qJpsBzTuoIbXEvr2YiE,17639
 qubx/core/lookups.py,sha256=PNOym2sxRRa0xQHTso8YDTqlHQ_dbZ3ohoJrUMNuba8,14779
 qubx/core/metrics.py,sha256=TOu3XkSd-RaR4QfuMeRioNFBn7-URTXDTkCKzPbzSkA,56577
 qubx/core/mixins/__init__.py,sha256=zdoxocPyKvdvs4N6HCDTfwli5n-f4MD5sDnoChboj7k,196
 qubx/core/mixins/market.py,sha256=s1NQDUjex7LR_ShnbSA3VnPMZpP7NmCgax5cmHdTmh4,3251
-qubx/core/mixins/processing.py,sha256=_QmlPvB_cU3i98KayzybabqYPGhP_B21jFUPl6Cjmgc,17560
+qubx/core/mixins/processing.py,sha256=dOERoe2TkNPihuXpb1lhawU78gCIdUukZNWThc-JeJY,18097
 qubx/core/mixins/subscription.py,sha256=J_SX0CNw2bPy4bhxe0vswvDXY4LCkwXSaj_1PepKRLY,8540
 qubx/core/mixins/trading.py,sha256=CQQIp1t1LJiFph5CiHQR4k4vxTymjFqrkA0awKYn4Dw,3224
-qubx/core/mixins/universe.py,sha256=2N6wPoVjACQMK3D477KiE4UBg8cuVxFJzqblvBSMjWc,5749
-qubx/core/series.cpython-311-x86_64-linux-gnu.so,sha256=Dx11oQrgo1io5s_eceAyrrRPh3fvwzpEFQg4FMzuwoM,816968
+qubx/core/mixins/universe.py,sha256=YRgud3dKU4C26hL4fr5bA81iHRf0_wDSxhPpuw-V6KY,10100
+qubx/core/series.cpython-311-x86_64-linux-gnu.so,sha256=yIO7MIBD84vrWHyuUMMEls_H-tDL1DRXapcdFyDxGLA,816968
 qubx/core/series.pxd,sha256=EqgYT41FrpVB274mDG3jpLCSqK_ykkL-d-1IH8DE1ik,3301
 qubx/core/series.pyi,sha256=zBt8DQCiIdTU3MLJz_9MlrONo7UCVYh2xYUltAcAj6c,3247
 qubx/core/series.pyx,sha256=4XCRdH3otXsU8EJ-g4_zLQfhqR8TVjtEq_e4oDz5mZ4,33836
-qubx/core/utils.cpython-311-x86_64-linux-gnu.so,sha256=ogh740NY72T9NMfjgT1aVrdx7QuHivdJW9ggukrVR00,82504
+qubx/core/utils.cpython-311-x86_64-linux-gnu.so,sha256=HHlmItv45pXUh0OMJgDAe91Lh-sn9OXuHKXSwWXKCfY,82504
 qubx/core/utils.pyi,sha256=DAjyRVPJSxK4Em-9wui2F0yYHfP5tI5DjKavXNOnHa8,276
 qubx/core/utils.pyx,sha256=k5QHfEFvqhqWfCob89ANiJDKNG8gGbOh-O4CVoneZ8M,1696
 qubx/data/__init__.py,sha256=ZBIOlciDTD44xyCYAJOngxwqxrKSgwJYDpMQdecPUIQ,245
@@ -61,7 +61,7 @@ qubx/resources/instruments/symbols-bitfinex.json,sha256=CpzoVgWzGZRN6RpUNhtJVxa3
 qubx/resources/instruments/symbols-kraken.f.json,sha256=lwNqml3H7lNUl1h3siySSyE1MRcGfqfhb6BcxLsiKr0,212258
 qubx/resources/instruments/symbols-kraken.json,sha256=RjUTvkQuuu7V1HfSQREvnA4qqkdkB3-rzykDaQds2rQ,456544
 qubx/ta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qubx/ta/indicators.cpython-311-x86_64-linux-gnu.so,sha256=bvad4VoqwSg4l10caAqMib0TBDUMDvmC4djUeIaLQ7c,609640
+qubx/ta/indicators.cpython-311-x86_64-linux-gnu.so,sha256=tvYCTlR745OMdCON34knmc9vwJXls021B_mjcSe913A,609640
 qubx/ta/indicators.pxd,sha256=eCJ9paOxtxbDFx4U5CUhcgB1jjCQAfVqMF2FnbJ03Lo,4222
 qubx/ta/indicators.pyi,sha256=NJlvN_774UV1U3_lvaYYbCEikLR8sOUo0TdcUGR5GBM,1940
 qubx/ta/indicators.pyx,sha256=FVkv5ld04TpZMT3a_kR1MU3IUuWfijzjJnh_lG78JxM,26029
@@ -92,9 +92,9 @@ qubx/utils/runner/__init__.py,sha256=axs9MF78BYk30jhHBu0gSXIr-IN5ZOzoprlJ_N85yN8
 qubx/utils/runner/_jupyter_runner.pyt,sha256=0SSc9F6caok_uRy9Qzy3L7hEuebZykH6U5QEM9YnhZU,2321
 qubx/utils/runner/accounts.py,sha256=3D9bqqG4MWVRw2YJ5iT1RgmyGRdTEBr7BDk1UephIUo,3237
 qubx/utils/runner/configs.py,sha256=nQXU1oqtSSGpGHw4cqk1dVpcojibj7bzjWZbDAHRxNc,1741
-qubx/utils/runner/runner.py,sha256=0Dp2piBStIYwx3BTCGBjnynZaXj_F8JfmP0Z1964mbE,17444
-qubx/utils/time.py,sha256=yYYAZvfXn79xE32nyoyJqBTdBbQum7-jzIiZf5xOi50,6612
-qubx-0.5.5.dist-info/METADATA,sha256=-Jd0-kM0OkoUsZLEc2MY152y2_4tWiNNZX9S4_uhQAY,3575
-qubx-0.5.5.dist-info/WHEEL,sha256=MLOa6LysROdjgj4FVxsHitAnIh8Be2D_c9ZSBHKrz2M,110
-qubx-0.5.5.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
-qubx-0.5.5.dist-info/RECORD,,
+qubx/utils/runner/runner.py,sha256=6dtiOGoi9V2coOu_NVcLBaQYzsaCv-bx1MKHOw8D910,17799
+qubx/utils/time.py,sha256=1Cvh077Uqf-XjcE5nWp_T9JzFVT6i39kU7Qz-ssHKIo,9630
+qubx-0.5.6.dist-info/METADATA,sha256=FhOj-B0n4SoT8ov2rWRmLtONccn_2-cnmzFONMa6Oko,3575
+qubx-0.5.6.dist-info/WHEEL,sha256=MLOa6LysROdjgj4FVxsHitAnIh8Be2D_c9ZSBHKrz2M,110
+qubx-0.5.6.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
+qubx-0.5.6.dist-info/RECORD,,