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

qubx/backtester/management.py

@@ -90,8 +90,12 @@ class BacktestsResultsManager:
             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', ''))}"
+
             if dscr:
-                _s += f"\n\t{magenta(dscr)}"
+                dscr = dscr.split("\n")
+                for _d in dscr:
+                    _s += f"\n\t{magenta('# ' + _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', '')})"
@@ -117,3 +121,21 @@ class BacktestsResultsManager:
                 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)} !")

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/interfaces.py

@@ -1003,6 +1003,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 +1023,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/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"Variation is enabled. There are {len(experiments)} simualtions to run.")
+        _n_jobs = -1
+    else:
+        strategy = stg_cls(**cfg.parameters)
+        experiments = {simulation_name: strategy}
+        _n_jobs = 1
 
     data_i = {}
 
@@ -409,13 +430,30 @@ 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])}")
+    # - 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)
 
     _where_to_save = save_path if save_path is not None else Path("results/")
-    s_path = Path(makedirs(str(_where_to_save))) / exp_name
-
-    logger.info(f"Saving results to <g>{s_path}</g> ...")
-    test_res[0].to_file(str(s_path))
+    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-0.5.3.dist-info → qubx-0.5.5.dist-info}/METADATA

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

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

@@ -4,11 +4,11 @@ qubx/backtester/__init__.py,sha256=2VP3RCc5y542IBYynV33rsZ4PD-zG-lijTbD3udD9Sg,1
 qubx/backtester/account.py,sha256=5lnLJq4i12vb8F2R-vuyXUs_UbapFSxLTTAL2IT1qGo,5807
 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=qprAmiyu23bhtC1UEU45V0GpfrMzZSMQ8pcfwvu3iUo,5510
 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
@@ -26,21 +26,21 @@ qubx/core/basics.py,sha256=pFfNYRGroQ1K0x54oZC7503sJA5r1GlENKfKq4PFIdM,27789
 qubx/core/context.py,sha256=IGNLwS28OUdNjbeWyugy_e0ut-XwnXwpd791LKjyBFc,15461
 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/interfaces.py,sha256=kkwf3Zy0LjKc2-WiZQ9dAR4OrEFVWAyI0j7bBo48O70,32663
 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/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/series.cpython-311-x86_64-linux-gnu.so,sha256=Dx11oQrgo1io5s_eceAyrrRPh3fvwzpEFQg4FMzuwoM,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=ogh740NY72T9NMfjgT1aVrdx7QuHivdJW9ggukrVR00,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=bvad4VoqwSg4l10caAqMib0TBDUMDvmC4djUeIaLQ7c,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/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.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-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,,