Qubx 0.6.53__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.54__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/management.py

@@ -3,6 +3,7 @@ import zipfile
 from collections import defaultdict
 from pathlib import Path
 
+import numpy as np
 import pandas as pd
 import yaml
 
@@ -230,6 +231,25 @@ class BacktestsResultsManager:
 
             yield info.get("idx", -1)
 
+    def list_variations(self, regex: str = "", detailed=True, sort_by: str | None = "sharpe", ascending=False):
+        """
+        List only variations of a backtest result.
+
+        Args:
+            - regex (str, optional): Regular expression pattern to filter results by strategy name or class. Defaults to "".
+            - sort_by (str, optional): The criterion to sort the results by. Defaults to "sharpe".
+            - ascending (bool, optional): Whether to sort the results in ascending order. Defaults to False.
+            - detailed (bool, optional): Whether to show each variation run. Defaults to True.
+        """
+        return self.list(
+            regex=regex,
+            sort_by=sort_by,
+            ascending=ascending,
+            show_variations=True,
+            show_simulations=False,
+            show_each_variation_run=detailed,
+        )
+
     def list(
         self,
         regex: str = "",
@@ -239,7 +259,9 @@ class BacktestsResultsManager:
         pretty_print=False,
         sort_by: str | None = "sharpe",
         ascending=False,
+        show_simulations=True,
         show_variations=True,
+        show_each_variation_run=True,
     ):
         """List backtesting results with optional filtering and formatting.
 
@@ -248,87 +270,93 @@ class BacktestsResultsManager:
             - 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.
+            - sort_by (str, optional): The criterion to sort the results by. Defaults to "sharpe".
+            - ascending (bool, optional): Whether to sort the results in ascending order. Defaults to False.
+            - show_simulations (bool, optional): Whether to show simulation results. Defaults to True.
+            - show_variations (bool, optional): Whether to show variation results. Defaults to True.
+            - show_each_variation_run (bool, optional): Whether to show each variation run. Defaults to True.
 
         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]
+        if show_simulations:
+            for n in sorted(self.results.keys()):
+                info = self.results[n]
+                s_cls = info.get("strategy_class", "").split(".")[-1]
 
-            if regex:
-                if not re.match(regex, n, re.IGNORECASE):
-                    # if not re.match(regex, s_cls, re.IGNORECASE):
-                    continue
+                if regex:
+                    if not re.match(regex, n, re.IGNORECASE):
+                        # if not re.match(regex, s_cls, re.IGNORECASE):
+                        continue
 
-            name = info.get("name", "")
-            smbs = ", ".join(info.get("symbols", list()))
-            start = pd.Timestamp(info.get("start", "")).round("1s")
-            stop = pd.Timestamp(info.get("stop", "")).round("1s")
-            dscr = info.get("description", "")
-            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 += "\u25cf " + _d + "\n"
-
-            _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', '')})"
-            _s += f"\n\tinstruments: {blue(smbs)}"
-            if params:
-                formats = ["{" + f":<{i}" + "}" for i in [50]]
-                _p = pd.DataFrame.from_dict(info.get("parameters", {}), orient="index")
-                for i in _p.to_string(
-                    max_colwidth=30,
-                    header=False,
-                    formatters=[(lambda x: cyan(fmt.format(str(x)))) for fmt in formats],
-                    justify="left",
-                ).split("\n"):
-                    _s += f"\n\t  |  {yellow(i)}"
-
-            if not as_table:
-                print(_s)
+                name = info.get("name", "")
+                smbs = ", ".join(info.get("symbols", list()))
+                start = pd.Timestamp(info.get("start", "")).round("1s")
+                stop = pd.Timestamp(info.get("stop", "")).round("1s")
+                dscr = info.get("description", "")
+                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 += "\u25cf " + _d + "\n"
+
+                _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', '')})"
+                _s += f"\n\tinstruments: {blue(smbs)}"
+                if params:
+                    formats = ["{" + f":<{i}" + "}" for i in [50]]
+                    _p = pd.DataFrame.from_dict(info.get("parameters", {}), orient="index")
+                    for i in _p.to_string(
+                        max_colwidth=30,
+                        header=False,
+                        formatters=[(lambda x: cyan(fmt.format(str(x)))) for fmt in formats],
+                        justify="left",
+                    ).split("\n"):
+                        _s += f"\n\t  |  {yellow(i)}"
 
-            if with_metrics:
-                _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,
-                    },
-                )
+                    print(_s)
+
+                if with_metrics:
+                    _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,
+                        },
+                    )
 
         # - variations (only if not as_table for the time being)
         if not as_table and show_variations:
@@ -358,11 +386,12 @@ class BacktestsResultsManager:
                 _m_repr = _m_repr.to_string(index=True)
 
                 print(_s)
-                for _i, _l in enumerate(_m_repr.split("\n")):
-                    if _i == 0:
-                        print("\t " + red(_l))
-                    else:
-                        print("\t " + blue(_l))
+                if show_each_variation_run:
+                    for _i, _l in enumerate(_m_repr.split("\n")):
+                        if _i == 0:
+                            print("\t " + red(_l))
+                        else:
+                            print("\t " + blue(_l))
 
         if as_table:
             _df = pd.DataFrame.from_records(_t_rep, index="Index")
@@ -376,3 +405,105 @@ class BacktestsResultsManager:
                     .replace("<td>", '<td align="left" valign="top">')
                 )
             return _df
+
+    def variation_plot(self, variation_idx: int, criterion: str = "sharpe", ascending: bool = False, n=3, h=600):
+        """
+        Plot a variation of a backtest result.
+
+        Args:
+            - variation_idx (int): The index of the variation to plot.
+            - criterion (str): The criterion to plot (e.g. "sharpe", "mdd_usd", "max_dd_pct", etc.).
+            - ascending (bool): Whether to sort the results in ascending order.
+            - n (int): The number of decimal places to display.
+            - h (int): The height of the plot.
+
+        Returns:
+            plotly.graph_objects.Figure: The plot of the variation.
+        """
+        import plotly.express as px
+        from itertools import cycle
+        from qubx.utils.misc import string_shortener
+
+        _vars = self.variations.get(variation_idx)
+        if not _vars:
+            raise ValueError(f"No variations found for index {variation_idx} !")
+
+        variations = _vars.get("variations", [])
+        name = _vars.get("name", "") or ""
+
+        _r, _p = {}, {}
+        for i, v in enumerate(variations):
+            _p[i] = v["parameters"]
+        _pp = pd.DataFrame.from_records(_p).T
+        # - changed parameters
+        _cp = []
+        for c in _pp.columns:
+            if len(_pp[c].astype(str).unique()) > 1:
+                _cp.append(c)
+
+        # - if nothing was actually changed in parameters, raise an error
+        if not _cp:
+            raise ValueError(f"No variable parameters found for simulation {name} !")
+
+        _ms = max([len(string_shortener(x)) for x in _cp]) + 3
+        _h = "".join([string_shortener(x).center(_ms) for x in _cp])
+
+        _sel = lambda ds, _cp: "".join(
+            [
+                f"<span style='color:{c}'> {str(ds[k]).center(_ms)}</span>"
+                for k, c in zip(_cp, cycle(px.colors.qualitative.Plotly))
+                if k in k in ds
+            ]
+        )
+        for i, v in enumerate(variations):
+            _r[i] = {"name": v["name"], **v["performance"], "parameters": _sel(v["parameters"], _cp)}
+
+        t1 = pd.DataFrame.from_records(_r).T
+        if criterion not in t1.columns:
+            raise ValueError(f"Criterion {criterion} not found in results: possible values are {t1.columns}")
+        t2 = t1.sort_values(criterion, ascending=ascending)
+
+        data = pd.Series([np.nan, *t2[criterion].to_list()], index=[_h, *t2["parameters"].to_list()])
+
+        figure = (
+            px.bar(data, orientation="h")
+            .update_layout(
+                title=dict(
+                    text=f"{name} | <span style='color:orange'>{criterion.capitalize()}</span>",
+                ),
+                xaxis=dict(tickfont=dict(family="monospace", size=10, color="#ff4000")),
+                yaxis=dict(
+                    tickfont=dict(family="monospace", size=10, color="#40a000"),
+                    dtick=1,
+                ),
+            )
+            .update_layout(
+                height=h,
+                hovermode="x unified",
+                showlegend=False,
+                hoverdistance=1,
+                yaxis={"hoverformat": f".{n}f"},
+                dragmode="zoom",
+                newshape=dict(line_color="red", line_width=1.0),
+                modebar_add=["drawline", "drawopenpath", "drawrect", "eraseshape"],
+                hoverlabel=dict(align="auto", bgcolor="rgba(10, 10, 10, 0.5)"),
+            )
+            .update_xaxes(
+                showspikes=True,
+                spikemode="across",
+                spikesnap="cursor",
+                spikecolor="#306020",
+                spikethickness=1,
+                spikedash="dot",
+                title=criterion,
+            )
+            .update_yaxes(
+                spikesnap="cursor",
+                spikecolor="#306020",
+                tickformat=f".{n}f",
+                spikethickness=1,
+                title="Parameters",
+                autorange="reversed",
+            )
+        )
+        return figure

qubx/core/mixins/processing.py

@@ -16,6 +16,7 @@ from qubx.core.basics import (
     Timestamped,
     TriggerEvent,
     dt_64,
+    td_64,
 )
 from qubx.core.errors import BaseErrorEvent
 from qubx.core.exceptions import StrategyExceededMaxNumberOfRuntimeFailuresError
@@ -40,7 +41,7 @@ from qubx.core.series import Bar, OrderBook, Quote, Trade
 
 class ProcessingManager(IProcessingManager):
     MAX_NUMBER_OF_STRATEGY_FAILURES: int = 10
-    DATA_READY_TIMEOUT_SECONDS: int = 60
+    DATA_READY_TIMEOUT: td_64 = td_64(60, "s")
 
     _context: IStrategyContext
     _strategy: IStrategy
@@ -69,6 +70,8 @@ class ProcessingManager(IProcessingManager):
     _cur_sim_step: int | None = None
     _updated_instruments: set[Instrument] = set()
     _data_ready_start_time: dt_64 | None = None
+    _last_data_ready_log_time: dt_64 | None = None
+    _all_instruments_ready_logged: bool = False
 
     def __init__(
         self,
@@ -114,6 +117,8 @@ class ProcessingManager(IProcessingManager):
         self._trig_bar_freq_nsec = None
         self._updated_instruments = set()
         self._data_ready_start_time = None
+        self._last_data_ready_log_time = None
+        self._all_instruments_ready_logged = False
 
     def set_fit_schedule(self, schedule: str) -> None:
         rule = process_schedule_spec(schedule)
@@ -350,7 +355,7 @@ class ProcessingManager(IProcessingManager):
         Check if strategy can start based on data availability with timeout logic.
 
         Two-phase approach:
-        - Phase 1 (0-DATA_READY_TIMEOUT_SECONDS): Wait for ALL instruments to have data
+        - Phase 1 (0-DATA_READY_TIMEOUT): Wait for ALL instruments to have data
         - Phase 2 (after timeout): Wait for at least 1 instrument to have data
 
         Returns:
@@ -363,39 +368,73 @@ class ProcessingManager(IProcessingManager):
             return True
 
         ready_instruments = len(self._updated_instruments)
+        current_time = self._time_provider.time()
 
         # Record start time on first call
         if self._data_ready_start_time is None:
-            self._data_ready_start_time = self._time_provider.time()
+            self._data_ready_start_time = current_time
 
         # Phase 1: Try to get all instruments ready within timeout
-        elapsed_time_seconds = (self._time_provider.time() - self._data_ready_start_time) / 1e9
+        elapsed_td = current_time - self._data_ready_start_time
 
-        if elapsed_time_seconds <= self.DATA_READY_TIMEOUT_SECONDS:
+        if elapsed_td <= self.DATA_READY_TIMEOUT:
             # Within timeout period - wait for ALL instruments
             if ready_instruments == total_instruments:
-                logger.info(f"All {total_instruments} instruments have data - strategy ready to start")
+                if not self._all_instruments_ready_logged:
+                    logger.info(f"All {total_instruments} instruments have data - strategy ready to start")
+                    self._all_instruments_ready_logged = True
                 return True
             else:
-                # Log periodic status during Phase 1
-                if int(elapsed_time_seconds) % 10 == 0 and elapsed_time_seconds > 0:  # Log every 10 seconds
+                # Log periodic status during Phase 1 - throttled to once per 10 seconds
+                elapsed_seconds = elapsed_td / td_64(1, "s")
+                should_log = self._last_data_ready_log_time is None or (
+                    current_time - self._last_data_ready_log_time
+                ) >= td_64(10, "s")
+
+                if should_log and elapsed_seconds > 0:
                     missing_instruments = set(self._context.instruments) - self._updated_instruments
                     missing_symbols = [inst.symbol for inst in missing_instruments]
+                    remaining_timeout = (self.DATA_READY_TIMEOUT - elapsed_td) / td_64(1, "s")
                     logger.info(
-                        f"Phase 1: Waiting for all instruments ({ready_instruments}/{total_instruments} ready). "
-                        f"Missing: {missing_symbols}. Timeout in {self.DATA_READY_TIMEOUT_SECONDS - elapsed_time_seconds}s"
+                        f"Waiting for all instruments ({ready_instruments}/{total_instruments} ready). "
+                        f"Missing: {missing_symbols}. Will start with partial data in {remaining_timeout:.0f}s"
                     )
+                    self._last_data_ready_log_time = current_time
                 return False
         else:
             # Phase 2: After timeout - need at least 1 instrument
-            if ready_instruments >= 1:
+            if ready_instruments == total_instruments:
+                if not self._all_instruments_ready_logged:
+                    logger.info(f"All {total_instruments} instruments have data - strategy ready to start")
+                    self._all_instruments_ready_logged = True
+                return True
+
+            elif ready_instruments >= 1:
                 missing_instruments = set(self._context.instruments) - self._updated_instruments
                 missing_symbols = [inst.symbol for inst in missing_instruments]
-                logger.info(
-                    f"Starting strategy with {ready_instruments}/{total_instruments} instruments ready. Missing: {missing_symbols}"
-                )
+
+                # Log once when entering Phase 2
+                should_log = self._last_data_ready_log_time is None or (
+                    current_time - self._last_data_ready_log_time
+                ) >= td_64(10, "s")
+                if should_log:
+                    logger.info(
+                        f"Timeout reached - starting with {ready_instruments}/{total_instruments} instruments ready. "
+                        f"Missing: {missing_symbols}"
+                    )
+                    self._last_data_ready_log_time = current_time
                 return True
             else:
+                # Still no instruments ready - keep waiting and log periodically
+                should_log = self._last_data_ready_log_time is None or (
+                    current_time - self._last_data_ready_log_time
+                ) >= td_64(10, "s")
+                if should_log:
+                    logger.warning(
+                        f"No instruments ready after timeout - still waiting "
+                        f"({ready_instruments}/{total_instruments} ready)"
+                    )
+                    self._last_data_ready_log_time = current_time
                 return False
 
     def __update_base_data(

qubx/data/composite.py

@@ -55,10 +55,22 @@ class IteratedDataStreamsSlicer(Iterator[SlicerOutData]):
         _keys = keys if isinstance(keys, list) else [keys]
         _rebuild = False
         for i in _keys:
+            # Check and remove from each data structure independently
+            removed_any = False
+
             if i in self._buffers:
                 self._buffers.pop(i)
+                removed_any = True
+
+            if i in self._iterators:
                 self._iterators.pop(i)
+                removed_any = True
+
+            if i in self._keys:
                 self._keys.remove(i)
+                removed_any = True
+
+            if removed_any:
                 _rebuild = True
 
         # - rebuild strategy
@@ -78,7 +90,7 @@ class IteratedDataStreamsSlicer(Iterator[SlicerOutData]):
     def _load_next_chunk_to_buffer(self, index: str) -> list[Timestamped]:
         try:
             return list(reversed(next(self._iterators[index])))
-        except StopIteration:
+        except (StopIteration, IndexError):
             return []
 
     def _remove_iterator(self, key: str):

{qubx-0.6.53.dist-info → qubx-0.6.54.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: Qubx
-Version: 0.6.53
+Version: 0.6.54
 Summary: Qubx - Quantitative Trading Framework
 Author: Dmitry Marienko
 Author-email: dmitry.marienko@xlydian.com

{qubx-0.6.53.dist-info → qubx-0.6.54.dist-info}/RECORD

@@ -4,7 +4,7 @@ qubx/backtester/__init__.py,sha256=OhXhLmj2x6sp6k16wm5IPATvv-E2qRZVIcvttxqPgcg,1
 qubx/backtester/account.py,sha256=0yvE06icSeK2ymovvaKkuftY8Ou3Z7Y2JrDa6VtkINw,3048
 qubx/backtester/broker.py,sha256=JMasxycLqCT99NxN50uyQ1uxtpHYL0wpp4sJ3hB6v2M,2688
 qubx/backtester/data.py,sha256=B1VHioLqBwA6ZnEgTn5Gere1vfOw0KvyFjGwm4vlByQ,6675
-qubx/backtester/management.py,sha256=HuyzFsBPgR7j-ei78Ngcx34CeSn65c9atmaii1aTsYg,14900
+qubx/backtester/management.py,sha256=FQSMkdrTZrxKdLRrf4Uiw60pdBMb0xESeFrTfH9AqZk,20713
 qubx/backtester/ome.py,sha256=BC8EuJkPTiGbl8HliHehVzwdD0OSDlR04g6RVA66FQE,18614
 qubx/backtester/optimization.py,sha256=HHUIYA6Y66rcOXoePWFOuOVX9iaHGKV0bGt_4d5e6FM,7619
 qubx/backtester/runner.py,sha256=TnNM0t8PgBE_gnCOZZTIOc28a3RqtXmp2Xj4Gq5j6bo,20504
@@ -49,19 +49,19 @@ qubx/core/lookups.py,sha256=aEuyZqd_N4cQ-oHz3coEHcdX9Yb0cP5-NwDuj-DQyNk,19477
 qubx/core/metrics.py,sha256=74xIecCvlxVXl0gy0JvgjJ2X5gg-RMmVZw9hQikkHE0,60269
 qubx/core/mixins/__init__.py,sha256=AMCLvfNuIb1kkQl3bhCj9jIOEl2eKcVPJeyLgrkB-rk,329
 qubx/core/mixins/market.py,sha256=lBappEimPhIuI0vmUvwVlIztkYjlEjJBpP-AdpfudII,3948
-qubx/core/mixins/processing.py,sha256=VEaK6ZjXTa8jvavj_VpCYfGvLFTHpNoL1AKdRAeear8,27394
+qubx/core/mixins/processing.py,sha256=oz-K-zs9T4lIp8zgMDpTnQH3eAdOvSsL74CYQeCrE3E,29319
 qubx/core/mixins/subscription.py,sha256=V_g9wCPQ8S5SHkU-qOZ84cV5nReAUrV7DoSNAGG0LPY,10372
 qubx/core/mixins/trading.py,sha256=idfRPaqrvkfMxzu9mXr9i_xfqLee-ZAOrERxkxv6Ruo,7256
 qubx/core/mixins/universe.py,sha256=tsMpBriLHwK9lAVYvIrO94EIx8_ETSXUlzxN_sDOsL8,9838
-qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=QesvTpTIRHYvNLxEFfXmSatYviRUvs6rgMTyBRYRZLE,978280
+qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=uyinYx_PzV6OQXmDgEoZ1x-nmJgyvbB3MFRscSM3HtU,978280
 qubx/core/series.pxd,sha256=jBdMwgO8J4Zrue0e_xQ5RlqTXqihpzQNu6V3ckZvvpY,3978
 qubx/core/series.pyi,sha256=RaHm_oHHiWiNUMJqVfx5FXAXniGLsHxUFOUpacn7GC0,4604
 qubx/core/series.pyx,sha256=7cM3zZThW59waHiYcZmMxvYj-HYD7Ej_l7nKA4emPjE,46477
-qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=-l0P2uf8Jv2W-kiPdDJBD6tn452rkk35d4cMAtEbQ4I,86568
+qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=nCrEL8ALt8zAaqO4OjTDshUk4UOAJtsiIA3dtm9JmZo,86568
 qubx/core/utils.pyi,sha256=a-wS13V2p_dM1CnGq40JVulmiAhixTwVwt0ah5By0Hc,348
 qubx/core/utils.pyx,sha256=k5QHfEFvqhqWfCob89ANiJDKNG8gGbOh-O4CVoneZ8M,1696
 qubx/data/__init__.py,sha256=ELZykvpPGWc5rX7QoNyNQwMLgdKMG8MACOByA4pM5hA,549
-qubx/data/composite.py,sha256=KGwjhZV-EjGKBAjip-Hrc9VuUwUvGCfLLsvZoVilMEg,18559
+qubx/data/composite.py,sha256=nLA3w3kMvzOc8n2rjAZ35sKa5DXAe8SOFsEov8PpES4,18881
 qubx/data/helpers.py,sha256=VcXBl1kfWzAOqrjadKrP9WemGjJIB0q3xascbesErh4,16268
 qubx/data/hft.py,sha256=be7AwzTOjqqCENn0ClrZoHDyKv3SFG66IyTp8QadHlM,33687
 qubx/data/readers.py,sha256=g3hSkyKdMAVziMCgcaZadsukidECaLwHyIEtArSVDSc,66203
@@ -124,7 +124,7 @@ qubx/restorers/signal.py,sha256=0QFoy7OzDkK6AAmJEbbmSsHwmAhjMJYYggVFuLraKjk,1089
 qubx/restorers/state.py,sha256=dLaVnUwRCNRkUqbYyi0RfZs3Q3AdglkI_qTtQ8GDD5Y,7289
 qubx/restorers/utils.py,sha256=We2gfqwQKWziUYhuUnjb-xo-5tSlbuHWpPQn0CEMTn0,1155
 qubx/ta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=AxK9diXnLxvqsjzDqFPECGOSWnHSWXQ_2Y9pD2Al2gg,654440
+qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=RMzIKbB01Sto83iqNyQqryMqRlA1k7bMHPTbWdBQFSA,654440
 qubx/ta/indicators.pxd,sha256=Goo0_N0Xnju8XGo3Xs-3pyg2qr_0Nh5C-_26DK8U_IE,4224
 qubx/ta/indicators.pyi,sha256=19W0uERft49In5bf9jkJHkzJYEyE9gzudN7_DJ5Vdv8,1963
 qubx/ta/indicators.pyx,sha256=Xgpew46ZxSXsdfSEWYn3A0Q35MLsopB9n7iyCsXTufs,25969
@@ -161,8 +161,8 @@ qubx/utils/runner/factory.py,sha256=eM4-Etcq-FewD2AjH_srFGzP413pm8er95KIZixXRpM,
 qubx/utils/runner/runner.py,sha256=O1hC8zyvj1OInMM9eZeAbUI9sdJbJU3INSnsOagvdAE,31444
 qubx/utils/time.py,sha256=J0ZFGjzFL5T6GA8RPAel8hKG0sg2LZXeQ5YfDCfcMHA,10055
 qubx/utils/version.py,sha256=e52fIHyxzCiIuH7svCF6pkHuDlqL64rklqz-2XjWons,5309
-qubx-0.6.53.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
-qubx-0.6.53.dist-info/METADATA,sha256=fsrCh6gjzv1zRlRyUEHjNZ7VDI6P7wT4ZqAcrvUIDJM,4612
-qubx-0.6.53.dist-info/WHEEL,sha256=UckHTmFUCaLKpi4yFY8Dewu0c6XkY-KvEAGzGOnaWo8,110
-qubx-0.6.53.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
-qubx-0.6.53.dist-info/RECORD,,
+qubx-0.6.54.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
+qubx-0.6.54.dist-info/METADATA,sha256=l-EdSHBJN0LZCQg-guiQOuvc53_Hj3FHBd4sn_4mNpY,4612
+qubx-0.6.54.dist-info/WHEEL,sha256=UckHTmFUCaLKpi4yFY8Dewu0c6XkY-KvEAGzGOnaWo8,110
+qubx-0.6.54.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
+qubx-0.6.54.dist-info/RECORD,,