Qubx 0.5.3__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,9 +170,18 @@ 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:
-                _s += f"\n\t{magenta(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)}"
             _s += f"\n\tcapital: {blue(info.get('capital', ''))} {info.get('base_currency', '')} ({info.get('commissions', '')})"
@@ -106,14 +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()
+                _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/backtester/simulator.py

@@ -57,6 +57,7 @@ def simulate(
     open_close_time_indent_secs=1,
     debug: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None = "WARNING",
     show_latency_report: bool = False,
+    parallel_backend: Literal["loky", "multiprocessing"] = "multiprocessing",
 ) -> list[TradingSessionResult]:
     """
     Backtest utility for trading strategies or signals using historical data.
@@ -149,6 +150,7 @@ def simulate(
         n_jobs=n_jobs,
         silent=silent,
         show_latency_report=show_latency_report,
+        parallel_backend=parallel_backend,
     )
 
 
@@ -160,6 +162,7 @@ def _run_setups(
     n_jobs: int = -1,
     silent: bool = False,
     show_latency_report: bool = False,
+    parallel_backend: Literal["loky", "multiprocessing"] = "multiprocessing",
 ) -> list[TradingSessionResult]:
     # loggers don't work well with joblib and multiprocessing in general because they contain
     # open file handlers that cannot be pickled. I found a solution which requires the usage of enqueue=True
@@ -170,7 +173,7 @@ def _run_setups(
     n_jobs = 1 if _main_loop_silent else n_jobs
 
     reports = ProgressParallel(
-        n_jobs=n_jobs, total=len(strategies_setups), silent=_main_loop_silent, backend="multiprocessing"
+        n_jobs=n_jobs, total=len(strategies_setups), silent=_main_loop_silent, backend=parallel_backend
     )(
         delayed(_run_setup)(id, f"Simulated-{id}", setup, data_setup, start, stop, silent, show_latency_report)
         for id, setup in enumerate(strategies_setups)

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."""
@@ -1003,6 +1029,18 @@ class PositionsTracker:
         ...
 
 
+def _unpickle_instance(chain: tuple[type], state: dict):
+    """
+    chain is a tuple of the *original* classes, e.g. (A, B, C).
+    Reconstruct a new ephemeral class that inherits from them.
+    """
+    name = "_".join(cls.__name__ for cls in chain)
+    # Reverse the chain to respect the typical left-to-right MRO
+    inst = type(name, chain[::-1], {"__module__": "__main__"})()
+    inst.__dict__.update(state)
+    return inst
+
+
 class Mixable(type):
     """
     It's possible to create composite strategies dynamically by adding mixins with functionality.
@@ -1011,8 +1049,28 @@ class Mixable(type):
     NewStrategy(....) can be used in simulation or live trading.
     """
 
-    def __add__(cls: type, other_cls: type):
-        return type(cls)(f"{cls.__name__}_{other_cls.__name__}", (other_cls, cls), {"__module__": cls.__module__})
+    def __add__(cls, other_cls):
+        # If we already have a _composition, combine them;
+        # else treat cls itself as the start of the chain
+        cls_chain = getattr(cls, "__composition__", (cls,))
+        other_chain = getattr(other_cls, "__composition__", (other_cls,))
+
+        # Combine them into one chain. You can define your own order rules:
+        new_chain = cls_chain + other_chain
+
+        # Create ephemeral class
+        name = "_".join(c.__name__ for c in new_chain)
+
+        def __reduce__(self):
+            # Just return the chain of *original real classes*
+            return _unpickle_instance, (new_chain, self.__dict__)
+
+        new_cls = type(
+            name,
+            new_chain[::-1],
+            {"__module__": cls.__module__, "__composition__": new_chain, "__reduce__": __reduce__},
+        )
+        return new_cls
 
 
 class IStrategy(metaclass=Mixable):

qubx/core/metrics.py

@@ -609,6 +609,7 @@ class TradingSessionResult:
     creation_time: pd.Timestamp | None = None        # when result was created
     author: str | None = None                        # who created the result
     qubx_version: str | None = None                  # Qubx version used to create the result
+    _metrics: dict[str, float] | None = None         # performance metrics
     # fmt: on
 
     def __init__(
@@ -649,6 +650,39 @@ class TradingSessionResult:
         self.creation_time = pd.Timestamp(creation_time) if creation_time else pd.Timestamp.now()
         self.author = author
         self.qubx_version = version()
+        self._metrics = None
+
+    def performance(self) -> dict[str, float]:
+        """
+        Calculate performance metrics for the trading session
+        """
+        if not self._metrics:
+            # - caluclate short statistics
+            self._metrics = portfolio_metrics(
+                self.portfolio_log,
+                self.executions_log,
+                self.capital,
+                performance_statistics_period=DAILY_365,
+                account_transactions=True,
+                commission_factor=1,
+            )
+            # - convert timestamps to isoformat
+            for k, v in self._metrics.items():
+                match v:
+                    case pd.Timestamp():
+                        self._metrics[k] = v.isoformat()
+                    case np.float64():
+                        self._metrics[k] = float(v)
+            # fmt: off
+            for k in [
+                "equity", "drawdown_usd", "drawdown_pct",
+                "compound_returns", "returns_daily", "returns", "monthly_returns",
+                "rolling_sharpe", "long_value", "short_value",
+            ]:
+                self._metrics.pop(k, None)
+            # fmt: on
+
+        return self._metrics
 
     @property
     def symbols(self) -> list[str]:
@@ -690,6 +724,7 @@ class TradingSessionResult:
             "author": self.author,
             "qubx_version": self.qubx_version,
             "symbols": self.symbols,
+            "performance": dict(self.performance()),
         }
 
     def to_html(self, compound=True) -> HTML:
@@ -743,8 +778,42 @@ class TradingSessionResult:
         """
         return HTML(_tmpl)
 
-    def to_file(self, name: str, description: str | None = None, compound=True, archive=True):
-        name = (name + self.creation_time.strftime("%Y%m%d%H%M%S")) if self.creation_time else name
+    def to_file(
+        self,
+        name: str,
+        description: str | None = None,
+        compound=True,
+        archive=True,
+        suffix: str | None = None,
+        attachments: list[str] | None = None,
+    ):
+        """
+        Save the trading session results to files.
+
+        Args:
+            name (str): Base name/path for saving the files
+            description (str | None, optional): Description to include in info file. Defaults to None.
+            compound (bool, optional): Whether to use compound returns in report. Defaults to True.
+            archive (bool, optional): Whether to zip the output files. Defaults to True.
+            suffix (str | None, optional): Optional suffix to append to filename. Defaults to None.
+            attachments (list[str] | None, optional): Additional files to include. Defaults to None.
+
+        The following files are saved:
+            - info.yml: Contains strategy configuration and metadata
+            - portfolio.csv: Portfolio state log
+            - executions.csv: Trade execution log
+            - signals.csv: Strategy signals log
+            - report.html: HTML performance report
+            - Any provided attachment files
+
+        If archive=True, all files are zipped into a single archive and the directory is removed.
+        """
+        import shutil
+
+        if suffix is not None:
+            name = f"{name}{suffix}"
+        else:
+            name = (name + self.creation_time.strftime("%Y%m%d%H%M%S")) if self.creation_time else name
         p = Path(makedirs(name))
         with open(p / "info.yml", "w") as f:
             info = self.info()
@@ -761,9 +830,13 @@ class TradingSessionResult:
         with open(p / "report.html", "w") as f:
             f.write(self.to_html(compound=compound).data)
 
-        if archive:
-            import shutil
+        # - save attachments
+        if attachments:
+            for a in attachments:
+                if (af := Path(a)).is_file():
+                    shutil.copy(af, p / af.name)
 
+        if archive:
             shutil.make_archive(name, "zip", p)  # type: ignore
             shutil.rmtree(p)  # type: ignore
 
@@ -784,9 +857,11 @@ class TradingSessionResult:
         # load result
         _qbx_version = info.pop("qubx_version")
         _decr = info.pop("description", None)
+        _perf = info.pop("performance", None)
         info["instruments"] = info.pop("symbols")
         tsr = TradingSessionResult(**info, portfolio_log=portfolio, executions_log=executions, signals_log=signals)
         tsr.qubx_version = _qbx_version
+        tsr._metrics = _perf
         return tsr
 
     def __repr__(self) -> str:
@@ -796,10 +871,13 @@ class TradingSessionResult:
  :   QUBX: {self.qubx_version}
  :   Capital: {self.capital} {self.base_currency} ({self.commissions} @ {self.exchange})
  :   Instruments: [{",".join(self.symbols)}]
- :   Generated: {len(self.signals_log)} signals, {len(self.executions_log)} executions
- :   Strategy: {self.config(False)}
  :   Created: {self.creation_time} by {self.author} 
-        """
+ :   Strategy: {self.config(False)}
+ :   Generated: {len(self.signals_log)} signals, {len(self.executions_log)} executions
+"""
+        _perf = pd.DataFrame.from_dict(self.performance(), orient="index").T.to_string(index=None)
+        for _i, s in enumerate(_perf.split("\n")):
+            r += f"       : {s}\n" if _i > 0 else f"  `----: {s}\n"
         return r
 
 

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/trackers/sizers.py

@@ -173,3 +173,57 @@ class LongShortRatioPortfolioSizer(IPositionSizer):
             t_pos.append(TargetPosition.create(ctx, signal, _p * _p_q))
 
         return t_pos
+
+
+class FixedRiskSizerWithConstantCapital(IPositionSizer):
+    def __init__(
+        self,
+        capital: float,
+        max_cap_in_risk: float,
+        max_allowed_position=np.inf,
+        divide_by_symbols: bool = True,
+    ):
+        """
+        Create fixed risk sizer calculator instance.
+        :param max_cap_in_risk: maximal risked capital (in percentage)
+        :param max_allowed_position: limitation for max position size in quoted currency (i.e. max 5000 in USDT)
+        :param reinvest_profit: if true use profit to reinvest
+        """
+        self.capital = capital
+        assert self.capital > 0, f" >> {self.__class__.__name__}: Capital must be positive, got {self.capital}"
+        self.max_cap_in_risk = max_cap_in_risk / 100
+        self.max_allowed_position_quoted = max_allowed_position
+        self.divide_by_symbols = divide_by_symbols
+
+    def calculate_target_positions(self, ctx: IStrategyContext, signals: List[Signal]) -> List[TargetPosition]:
+        t_pos = []
+        for signal in signals:
+            target_position_size = 0
+            if signal.signal != 0:
+                if signal.stop and signal.stop > 0:
+                    # - get signal entry price
+                    if (_entry := self.get_signal_entry_price(ctx, signal)) is None:
+                        continue
+
+                    # - just use same fixed capital
+                    _cap = self.capital / (len(ctx.instruments) if self.divide_by_symbols else 1)
+
+                    # fmt: off
+                    _direction = np.sign(signal.signal)
+                    target_position_size = (  
+                        _direction * min(
+                            (_cap * self.max_cap_in_risk) / abs(signal.stop / _entry - 1), 
+                            self.max_allowed_position_quoted
+                        ) / _entry
+                    )  
+                    # fmt: on
+
+                else:
+                    logger.warning(
+                        f" >>> {self.__class__.__name__}: stop is not specified for {str(signal)} - can't calculate position !"
+                    )
+                    continue
+
+            t_pos.append(TargetPosition.create(ctx, signal, target_position_size))
+
+        return t_pos

qubx/utils/runner/configs.py

@@ -55,6 +55,8 @@ class StrategySimulationConfig(BaseModel):
     parameters: dict = Field(default_factory=dict)
     data: dict = Field(default_factory=dict)
     simulation: dict = Field(default_factory=dict)
+    description: str | list[str] | None = None
+    variate: dict = Field(default_factory=dict)
 
 
 def load_simulation_config_from_yaml(path: Path | str) -> StrategySimulationConfig:

qubx/utils/runner/runner.py

@@ -4,8 +4,11 @@ import time
 from functools import reduce
 from pathlib import Path
 
+import pandas as pd
+
 from qubx import formatter, logger, lookup
 from qubx.backtester.account import SimulatedAccountProcessor
+from qubx.backtester.optimization import variate
 from qubx.backtester.simulator import SimulatedBroker, simulate
 from qubx.connectors.ccxt.account import CcxtAccountProcessor
 from qubx.connectors.ccxt.broker import CcxtBroker
@@ -18,7 +21,7 @@ from qubx.core.helpers import BasicScheduler
 from qubx.core.interfaces import IAccountProcessor, IBroker, IDataProvider, IStrategyContext
 from qubx.core.loggers import StrategyLogging
 from qubx.data import DataReader
-from qubx.utils.misc import class_import, makedirs
+from qubx.utils.misc import blue, class_import, cyan, green, magenta, makedirs, red, yellow
 from qubx.utils.runner.configs import ExchangeConfig, load_simulation_config_from_yaml, load_strategy_config_from_yaml
 
 from .accounts import AccountConfigurationManager
@@ -379,6 +382,8 @@ def simulate_strategy(
 
     cfg = load_simulation_config_from_yaml(config_file)
     stg = cfg.strategy
+    simulation_name = config_file.stem
+    _v_id = pd.Timestamp("now").strftime("%Y%m%d%H%M%S")
 
     match stg:
         case list():
@@ -388,8 +393,24 @@ def simulate_strategy(
         case _:
             raise SimulationConfigError(f"Invalid strategy type: {stg}")
 
-    strategy = stg_cls(**cfg.parameters)
-    exp_name = config_file.stem
+    # - create simulation setup
+    if cfg.variate:
+        # - get conditions for variations if exists
+        cond = cfg.variate.pop("with", None)
+        conditions = []
+        dict2lambda = lambda a, d: eval(f"lambda {a}: {d}")  # noqa: E731
+        if cond:
+            for a, c in cond.items():
+                conditions.append(dict2lambda(a, c))
+
+        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"Parameters variation is configured. There are {len(experiments)} simulations to run.")
+        _n_jobs = -1
+    else:
+        strategy = stg_cls(**cfg.parameters)
+        experiments = {simulation_name: strategy}
+        _n_jobs = 1
 
     data_i = {}
 
@@ -409,13 +430,39 @@ def simulate_strategy(
         sim_params["stop"] = stop
         logger.info(f"Stop date set to {stop}")
 
-    test_res = simulate({exp_name: strategy}, data=data_i, **sim_params)
-    logger.info(f"<g>Simulation Results:</g>\n{str(test_res[0])}")
+    # - 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
 
-    _where_to_save = save_path if save_path is not None else Path("results/")
-    s_path = Path(makedirs(str(_where_to_save))) / exp_name
+    # - 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)
+    test_res = simulate(experiments, data=data_i, **sim_params)
 
-    logger.info(f"Saving results to <g>{s_path}</g> ...")
-    test_res[0].to_file(str(s_path))
+    _where_to_save = save_path if save_path is not None else Path("results/")
+    s_path = Path(makedirs(str(_where_to_save))) / simulation_name
+
+    # logger.info(f"Saving simulation results to <g>{s_path}</g> ...")
+    if cfg.description is not None:
+        _descr = cfg.description
+        if isinstance(cfg.description, list):
+            _descr = "\n".join(cfg.description)
+        else:
+            _descr = str(cfg.description)
+
+    if len(test_res) > 1:
+        # - TODO: think how to deal with variations !
+        s_path = s_path / f"variations.{_v_id}"
+        print(f" > Saving variations results to <g>{s_path}</g> ...")
+        for k, t in enumerate(test_res):
+            t.to_file(str(s_path), description=_descr, suffix=f".{k}", attachments=[str(config_file)])
+    else:
+        print(f" > Saving simulation results to <g>{s_path}</g> ...")
+        test_res[0].to_file(str(s_path), description=_descr, attachments=[str(config_file)])
 
     return test_res

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.3.dist-info → qubx-0.5.6.dist-info}/METADATA

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

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

@@ -1,14 +1,14 @@
 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=L5t1Xc5_j6ulSraRK-RC6hWiVU2KtTSycod5RATk8E0,4660
+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
-qubx/backtester/simulator.py,sha256=2LCCZwEIQkRmYyBA8DAWfGwmX_zBcmqBWbxwIUMc97I,14182
+qubx/backtester/simulator.py,sha256=nkoCD3JQ6eUPxyo1e1lB7lLpd5_IwtB4oR7VpKaE0sI,14380
 qubx/backtester/utils.py,sha256=V8ethHIUhs3o85q1ssWwJj1s6NplwVpdzOFIjluUd3A,30483
 qubx/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubx/cli/commands.py,sha256=SMl7Zax3OiWjB5M4fFh5w0bIVI4OLJrYUDsamjCe7_w,2276
@@ -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=dtIq8QWhOAWdIkVcVkXIc2ykecjiYcjGYoZ_z_el1z0,31533
+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=qMoUD7Y4XT-RIBQkkD6rXDuy1hQN9OO59072CXMgMNQ,53472
+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=ZcQ4ztHMtQURn-JVOlzeQAEPOfIB9n7ifkXs91bc4ik,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=Tek9kkT7PvVWHHoeOLqOxnosivqOIJYgRQxKCTcuN0Y,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=6OkgN8qfi-kPSCRVHRm8T-XO7E--cMCytGpP-8EhKiA,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
@@ -70,7 +70,7 @@ qubx/trackers/abvanced.py,sha256=vo4DuX6sYzsXLcp5z1UYuGowlJEE47vzmSoKsMLBPu4,103
 qubx/trackers/composite.py,sha256=W-n1vd4l-RZEoojj6lICqvJ8EgTV2kE6JUUmZUkZ1cI,6339
 qubx/trackers/rebalancers.py,sha256=5Dx39QZ67iZVx-cfpYx4IoMgDd7-fCHvGkwtezL7ofY,5269
 qubx/trackers/riskctrl.py,sha256=CawDn6x3cEyJFbhbLl4yg3pnwzJbRT9UCy2L-W6wXek,26085
-qubx/trackers/sizers.py,sha256=T4szog1x8QFksWQdOAIPXliTwtn_GJhWX_kSbfOnnZU,7018
+qubx/trackers/sizers.py,sha256=tIo3kOvfdv9vG4v4_Cq1VfunFOghn08BhI8F2QPvJd0,9250
 qubx/utils/__init__.py,sha256=pIS1ulI6Hj8btZlPd5P9To7DlyEY20bEVvFREAZkR0A,384
 qubx/utils/_pyxreloader.py,sha256=FyqGzfSpZGYziB8JYS5AP3cLRAvJSIPAKgwQn0E4YQ0,12017
 qubx/utils/charting/lookinglass.py,sha256=m7lWU8c0E8tXzGbkN0GB8CL-kd92MnH_wD8cATX067k,39232
@@ -91,10 +91,10 @@ qubx/utils/plotting/renderers/plotly.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 qubx/utils/runner/__init__.py,sha256=axs9MF78BYk30jhHBu0gSXIr-IN5ZOzoprlJ_N85yN8,77
 qubx/utils/runner/_jupyter_runner.pyt,sha256=0SSc9F6caok_uRy9Qzy3L7hEuebZykH6U5QEM9YnhZU,2321
 qubx/utils/runner/accounts.py,sha256=3D9bqqG4MWVRw2YJ5iT1RgmyGRdTEBr7BDk1UephIUo,3237
-qubx/utils/runner/configs.py,sha256=EsqN-ZBGOvMruSGZe1plYx7zoLWmlNHOQsnoZLFxgAA,1646
-qubx/utils/runner/runner.py,sha256=dHzr8dDinYrh09nYO59cAax2jlZiGNTJU9Cql8UVHv4,15693
-qubx/utils/time.py,sha256=yYYAZvfXn79xE32nyoyJqBTdBbQum7-jzIiZf5xOi50,6612
-qubx-0.5.3.dist-info/METADATA,sha256=CC5_d274APOOQihoP83ByaJL4zZetoy31AGMMKBqWq0,3575
-qubx-0.5.3.dist-info/WHEEL,sha256=MLOa6LysROdjgj4FVxsHitAnIh8Be2D_c9ZSBHKrz2M,110
-qubx-0.5.3.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
-qubx-0.5.3.dist-info/RECORD,,
+qubx/utils/runner/configs.py,sha256=nQXU1oqtSSGpGHw4cqk1dVpcojibj7bzjWZbDAHRxNc,1741
+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,,