Qubx 0.6.49__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.52__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/data.py

@@ -139,26 +139,31 @@ class SimulatedDataProvider(IDataProvider):
         bars = []
 
         # - if no records, return empty list to avoid exception from infer_series_frequency
-        if not records:
+        if not records or records is None:
             return bars
 
-        _data_tf = infer_series_frequency([r.time for r in records[:50]])
-        timeframe_ns = _data_tf.item()
-
-        if records is not None:
-            for r in records:
-                # _b_ts_0 = np.datetime64(r.time, "ns").item()
-                _b_ts_0 = r.time
-                _b_ts_1 = _b_ts_0 + timeframe_ns - self._open_close_time_indent_ns
-
-                if _b_ts_0 <= cut_time_ns and cut_time_ns < _b_ts_1:
-                    break
-
-                bars.append(
-                    Bar(
-                        _b_ts_0, r.data["open"], r.data["high"], r.data["low"], r.data["close"], r.data.get("volume", 0)
-                    )
+        if len(records) > 1:
+            _data_tf = infer_series_frequency([r.time for r in records[:50]])
+            timeframe_ns = _data_tf.item()
+
+        for r in records:
+            _b_ts_0 = r.time
+            _b_ts_1 = _b_ts_0 + timeframe_ns - self._open_close_time_indent_ns
+
+            if _b_ts_0 <= cut_time_ns and cut_time_ns < _b_ts_1:
+                break
+
+            bars.append(
+                Bar(
+                    _b_ts_0,
+                    r.data["open"],
+                    r.data["high"],
+                    r.data["low"],
+                    r.data["close"],
+                    r.data.get("volume", 0),
+                    r.data.get("bought_volume", 0),
                 )
+            )
 
         return bars
 

qubx/backtester/simulator.py

@@ -48,6 +48,7 @@ def simulate(
     portfolio_log_freq: str = "5Min",
     parallel_backend: Literal["loky", "multiprocessing"] = "multiprocessing",
     emission: EmissionConfig | None = None,
+    run_separate_instruments: bool = False,
 ) -> list[TradingSessionResult]:
     """
     Backtest utility for trading strategies or signals using historical data.
@@ -73,6 +74,7 @@ def simulate(
         - portfolio_log_freq (str): Frequency for portfolio logging, default is "5Min".
         - parallel_backend (Literal["loky", "multiprocessing"]): Backend for parallel processing, default is "multiprocessing".
         - emission (EmissionConfig | None): Configuration for metric emitters, default is None.
+        - run_separate_instruments (bool): If True, creates separate simulation setups for each instrument, default is False.
 
     Returns:
         - list[TradingSessionResult]: A list of TradingSessionResult objects containing the results of each simulation setup.
@@ -109,6 +111,7 @@ def simulate(
         commissions=commissions,
         signal_timeframe=signal_timeframe,
         accurate_stop_orders_execution=accurate_stop_orders_execution,
+        run_separate_instruments=run_separate_instruments,
     )
     if not simulation_setups:
         logger.error(
@@ -117,6 +120,10 @@ def simulate(
         )
         raise SimulationError(_msg)
 
+    # - inform about separate instruments mode
+    if run_separate_instruments and len(simulation_setups) > 1:
+        logger.info(f"Running separate simulations for each instrument. Total simulations: {len(simulation_setups)}")
+
     # - preprocess start and stop and convert to datetime if necessary
     if stop is None:
         # - check stop time : here we try to backtest till now (may be we need to get max available time from data reader ?)
@@ -160,24 +167,50 @@ def _run_setups(
     _main_loop_silent = len(strategies_setups) == 1
     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=parallel_backend
-    )(
-        delayed(_run_setup)(
-            id,
-            f"Simulated-{id}",
-            setup,
-            data_setup,
-            start,
-            stop,
-            silent,
-            show_latency_report,
-            portfolio_log_freq,
-            emission,
+    if n_jobs == 1:
+        reports = [
+            _run_setup(
+                id,
+                f"Simulated-{id}",
+                setup,
+                data_setup,
+                start,
+                stop,
+                silent,
+                show_latency_report,
+                portfolio_log_freq,
+                emission,
+            )
+            for id, setup in enumerate(strategies_setups)
+        ]
+    else:
+        reports = ProgressParallel(
+            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,
+                portfolio_log_freq,
+                emission,
+            )
+            for id, setup in enumerate(strategies_setups)
         )
-        for id, setup in enumerate(strategies_setups)
-    )
-    return reports  # type: ignore
+
+    # Filter out None results and log warnings for failed simulations
+    successful_reports = []
+    for i, report in enumerate(reports):
+        if report is None:
+            logger.warning(f"Simulation setup {i} failed - skipping from results")
+        else:
+            successful_reports.append(report)
+
+    return successful_reports
 
 
 def _run_setup(
@@ -191,48 +224,58 @@ def _run_setup(
     show_latency_report: bool,
     portfolio_log_freq: str,
     emission: EmissionConfig | None = None,
-) -> TradingSessionResult:
-    # Create metric emitter if configured
-    emitter = None
-    if emission is not None:
-        emitter = create_metric_emitters(emission, setup.name)
-
-    runner = SimulationRunner(
-        setup=setup,
-        data_config=data_setup,
-        start=start,
-        stop=stop,
-        account_id=account_id,
-        portfolio_log_freq=portfolio_log_freq,
-        emitter=emitter,
-    )
+) -> TradingSessionResult | None:
+    try:
+        # Create metric emitter if configured
+        emitter = None
+        if emission is not None:
+            emitter = create_metric_emitters(emission, setup.name)
 
-    # - we want to see simulate time in log messages
-    QubxLogConfig.setup_logger(
-        level=QubxLogConfig.get_log_level(), custom_formatter=SimulatedLogFormatter(runner.ctx).formatter
-    )
+        runner = SimulationRunner(
+            setup=setup,
+            data_config=data_setup,
+            start=start,
+            stop=stop,
+            account_id=account_id,
+            portfolio_log_freq=portfolio_log_freq,
+            emitter=emitter,
+        )
 
-    runner.run(silent=silent)
-
-    # - service latency report
-    if show_latency_report:
-        runner.print_latency_report()
-
-    return TradingSessionResult(
-        setup_id,
-        setup.name,
-        start,
-        stop,
-        setup.exchanges,
-        setup.instruments,
-        setup.capital,
-        setup.base_currency,
-        setup.commissions,
-        runner.logs_writer.get_portfolio(as_plain_dataframe=True),
-        runner.logs_writer.get_executions(),
-        runner.logs_writer.get_signals(),
-        strategy_class=runner.strategy_class,
-        parameters=runner.strategy_params,
-        is_simulation=True,
-        author=get_current_user(),
-    )
+        # - we want to see simulate time in log messages
+        QubxLogConfig.setup_logger(
+            level=QubxLogConfig.get_log_level(), custom_formatter=SimulatedLogFormatter(runner.ctx).formatter
+        )
+
+        runner.run(silent=silent)
+
+        # - service latency report
+        if show_latency_report:
+            runner.print_latency_report()
+
+        # Convert commissions to the expected type for TradingSessionResult
+        commissions_for_result = setup.commissions
+        if isinstance(commissions_for_result, dict):
+            # Filter out None values to match TradingSessionResult expected type
+            commissions_for_result = {k: v for k, v in commissions_for_result.items() if v is not None}
+
+        return TradingSessionResult(
+            setup_id,
+            setup.name,
+            start,
+            stop,
+            setup.exchanges,
+            setup.instruments,
+            setup.capital,
+            setup.base_currency,
+            commissions_for_result,
+            runner.logs_writer.get_portfolio(as_plain_dataframe=True),
+            runner.logs_writer.get_executions(),
+            runner.logs_writer.get_signals(),
+            strategy_class=runner.strategy_class,
+            parameters=runner.strategy_params,
+            is_simulation=True,
+            author=get_current_user(),
+        )
+    except Exception as e:
+        logger.error(f"Simulation setup {setup_id} failed with error: {e}")
+        return None

qubx/backtester/utils.py

@@ -419,6 +419,7 @@ def recognize_simulation_configuration(
     commissions: str | dict[str, str | None] | None,
     signal_timeframe: str,
     accurate_stop_orders_execution: bool,
+    run_separate_instruments: bool = False,
 ) -> list[SimulationSetup]:
     """
     Recognize and create setups based on the provided simulation configuration.
@@ -438,6 +439,7 @@ def recognize_simulation_configuration(
     - commissions (str): The commission structure to be applied.
     - signal_timeframe (str): Timeframe for generated signals.
     - accurate_stop_orders_execution (bool): If True, enables more accurate stop order execution simulation.
+    - run_separate_instruments (bool): If True, creates separate setups for each instrument.
 
     Returns:
     - list[SimulationSetup]: A list of SimulationSetup objects, each representing a
@@ -458,7 +460,7 @@ def recognize_simulation_configuration(
             r.extend(
                 recognize_simulation_configuration(
                     _n + n, v, instruments, exchanges, capital, basic_currency, commissions, 
-                    signal_timeframe, accurate_stop_orders_execution
+                    signal_timeframe, accurate_stop_orders_execution, run_separate_instruments
                 )
             )
 
@@ -474,45 +476,85 @@ def recognize_simulation_configuration(
                 _t = SetupTypes.STRATEGY_AND_TRACKER
 
             # - extract actual symbols that have signals
-            r.append(
-                SimulationSetup(
-                    _t, name, _s, c1,   # type: ignore
-                    _sniffer._pick_instruments(instruments, _s) if _sniffer._is_signal(c0) else instruments,
-                    exchanges, capital, basic_currency, commissions, 
-                    signal_timeframe, accurate_stop_orders_execution
+            setup_instruments = _sniffer._pick_instruments(instruments, _s) if _sniffer._is_signal(c0) else instruments
+            
+            if run_separate_instruments:
+                # Create separate setups for each instrument
+                for instrument in setup_instruments:
+                    r.append(
+                        SimulationSetup(
+                            _t, f"{name}/{instrument.symbol}", _s, c1,   # type: ignore
+                            [instrument],
+                            exchanges, capital, basic_currency, commissions, 
+                            signal_timeframe, accurate_stop_orders_execution
+                        )
+                    )
+            else:
+                r.append(
+                    SimulationSetup(
+                        _t, name, _s, c1,   # type: ignore
+                        setup_instruments,
+                        exchanges, capital, basic_currency, commissions, 
+                        signal_timeframe, accurate_stop_orders_execution
+                    )
                 )
-            )
         else:
             for j, s in enumerate(configs):
                 r.extend(
                     recognize_simulation_configuration(
                         # name + "/" + str(j), s, instruments, exchange, capital, basic_currency, commissions
                         name, s, instruments, exchanges, capital, basic_currency, commissions,  # type: ignore
-                        signal_timeframe, accurate_stop_orders_execution
+                        signal_timeframe, accurate_stop_orders_execution, run_separate_instruments
                     )
                 )
 
     elif _sniffer._is_strategy(configs):
-        r.append(
-            SimulationSetup(
-                SetupTypes.STRATEGY,
-                name, configs, None, instruments,
-                exchanges, capital, basic_currency, commissions, 
-                signal_timeframe, accurate_stop_orders_execution
+        if run_separate_instruments:
+            # Create separate setups for each instrument
+            for instrument in instruments:
+                r.append(
+                    SimulationSetup(
+                        SetupTypes.STRATEGY,
+                        f"{name}/{instrument.symbol}", configs, None, [instrument],
+                        exchanges, capital, basic_currency, commissions, 
+                        signal_timeframe, accurate_stop_orders_execution
+                    )
+                )
+        else:
+            r.append(
+                SimulationSetup(
+                    SetupTypes.STRATEGY,
+                    name, configs, None, instruments,
+                    exchanges, capital, basic_currency, commissions, 
+                    signal_timeframe, accurate_stop_orders_execution
+                )
             )
-        )
 
     elif _sniffer._is_signal(configs):
         # - check structure of signals
         c1 = _sniffer._check_signals_structure(instruments, configs)  # type: ignore
-        r.append(
-            SimulationSetup(
-                SetupTypes.SIGNAL,
-                name, c1, None, _sniffer._pick_instruments(instruments, c1),
-                exchanges, capital, basic_currency, commissions, 
-                signal_timeframe, accurate_stop_orders_execution
+        setup_instruments = _sniffer._pick_instruments(instruments, c1)
+        
+        if run_separate_instruments:
+            # Create separate setups for each instrument
+            for instrument in setup_instruments:
+                r.append(
+                    SimulationSetup(
+                        SetupTypes.SIGNAL,
+                        f"{name}/{instrument.symbol}", c1, None, [instrument],
+                        exchanges, capital, basic_currency, commissions, 
+                        signal_timeframe, accurate_stop_orders_execution
+                    )
+                )
+        else:
+            r.append(
+                SimulationSetup(
+                    SetupTypes.SIGNAL,
+                    name, c1, None, setup_instruments,
+                    exchanges, capital, basic_currency, commissions, 
+                    signal_timeframe, accurate_stop_orders_execution
+                )
             )
-        )
 
     # fmt: on
     return r

qubx/core/loggers.py

@@ -10,10 +10,8 @@ from qubx.core.basics import (
     Position,
     TargetPosition,
 )
-
 from qubx.core.series import time_as_nsec
 from qubx.core.utils import recognize_timeframe
-
 from qubx.utils.misc import Stopwatch
 from qubx.utils.time import convert_tf_str_td64, floor_t64
 
@@ -21,14 +19,14 @@ _SW = Stopwatch()
 
 
 class LogsWriter:
-    account_id: str
-    strategy_id: str
-    run_id: str
-
     """
     Log writer interface with default implementation
     """
 
+    account_id: str
+    strategy_id: str
+    run_id: str
+
     def __init__(self, account_id: str, strategy_id: str, run_id: str) -> None:
         self.account_id = account_id
         self.strategy_id = strategy_id

qubx/core/mixins/processing.py

@@ -39,7 +39,8 @@ from qubx.core.series import Bar, OrderBook, Quote, Trade
 
 
 class ProcessingManager(IProcessingManager):
-    MAX_NUMBER_OF_STRATEGY_FAILURES = 10
+    MAX_NUMBER_OF_STRATEGY_FAILURES: int = 10
+    DATA_READY_TIMEOUT_SECONDS: int = 60
 
     _context: IStrategyContext
     _strategy: IStrategy
@@ -67,6 +68,7 @@ class ProcessingManager(IProcessingManager):
     _trig_bar_freq_nsec: int | None = None
     _cur_sim_step: int | None = None
     _updated_instruments: set[Instrument] = set()
+    _data_ready_start_time: dt_64 | None = None
 
     def __init__(
         self,
@@ -111,6 +113,7 @@ class ProcessingManager(IProcessingManager):
         self._strategy_name = strategy.__class__.__name__
         self._trig_bar_freq_nsec = None
         self._updated_instruments = set()
+        self._data_ready_start_time = None
 
     def set_fit_schedule(self, schedule: str) -> None:
         rule = process_schedule_spec(schedule)
@@ -344,9 +347,56 @@ class ProcessingManager(IProcessingManager):
 
     def _is_data_ready(self) -> bool:
         """
-        Check if at least one update was received for all instruments in the context.
+        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 2 (after timeout): Wait for at least 1 instrument to have data
+
+        Returns:
+            bool: True if strategy can start, False if still waiting
         """
-        return all(instrument in self._updated_instruments for instrument in self._context.instruments)
+        total_instruments = len(self._context.instruments)
+
+        # Handle edge case: no instruments
+        if total_instruments == 0:
+            return True
+
+        ready_instruments = len(self._updated_instruments)
+
+        # Record start time on first call
+        if self._data_ready_start_time is None:
+            self._data_ready_start_time = self._time_provider.time()
+
+        # Phase 1: Try to get all instruments ready within timeout
+        elapsed_time_seconds = (self._time_provider.time() - self._data_ready_start_time) / 1e9
+
+        if elapsed_time_seconds <= self.DATA_READY_TIMEOUT_SECONDS:
+            # 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")
+                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
+                    missing_instruments = set(self._context.instruments) - self._updated_instruments
+                    missing_symbols = [inst.symbol for inst in missing_instruments]
+                    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"
+                    )
+                return False
+        else:
+            # Phase 2: After timeout - need at least 1 instrument
+            if 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}"
+                )
+                return True
+            else:
+                return False
 
     def __update_base_data(
         self, instrument: Instrument, event_type: str, data: Timestamped, is_historical: bool = False

qubx/core/mixins/universe.py

@@ -114,11 +114,12 @@ class UniverseManager(IUniverseManager):
                 self._removal_queue.pop(instr)
 
     def add_instruments(self, instruments: list[Instrument]):
-        self.__do_add_instruments(instruments)
+        to_add = list(set([instr for instr in instruments if instr not in self._instruments]))
+        self.__do_add_instruments(to_add)
         self.__cleanup_removal_queue(instruments)
-        self._strategy.on_universe_change(self._context, instruments, [])
+        self._strategy.on_universe_change(self._context, to_add, [])
         self._subscription_manager.commit()
-        self._instruments.update(instruments)
+        self._instruments.update(to_add)
 
     def remove_instruments(
         self,

qubx/data/composite.py

@@ -71,12 +71,15 @@ class IteratedDataStreamsSlicer(Iterator[SlicerOutData]):
         return self
 
     def _build_initial_iteration_seq(self):
-        _init_seq = {k: self._time_func(self._buffers[k][-1]) for k in self._keys}
+        _init_seq = {k: self._time_func(self._buffers[k][-1]) for k in self._keys if self._buffers[k]}
         _init_seq = dict(sorted(_init_seq.items(), key=lambda item: item[1]))
         self._keys = deque(_init_seq.keys())
 
     def _load_next_chunk_to_buffer(self, index: str) -> list[Timestamped]:
-        return list(reversed(next(self._iterators[index])))
+        try:
+            return list(reversed(next(self._iterators[index])))
+        except StopIteration:
+            return []
 
     def _remove_iterator(self, key: str):
         self._buffers.pop(key)
@@ -95,6 +98,9 @@ class IteratedDataStreamsSlicer(Iterator[SlicerOutData]):
         Returns:
             Timestamped: The most recent timestamped data element from the buffer.
         """
+        if not self._buffers[k]:
+            raise StopIteration
+
         v = (data := self._buffers[k]).pop()
         if not data:
             try:
@@ -154,6 +160,9 @@ class IteratedDataStreamsSlicer(Iterator[SlicerOutData]):
         _min_t = math.inf
         _min_k = self._keys[0]
         for i in self._keys:
+            if not self._buffers[i]:
+                continue
+
             _x = self._buffers[i][-1]
             if self._time_func(_x) < _min_t:
                 _min_t = self._time_func(_x)

qubx/data/readers.py

@@ -1469,6 +1469,11 @@ class QuestDBConnector(DataReader):
             # Use efficient chunking with multiple smaller queries
             def _iter_efficient_chunks():
                 time_windows = _calculate_time_windows_for_chunking(start, end, effective_timeframe, chunksize)
+                if self._connection is None:
+                    self._connect()
+                    if self._connection is None:
+                        raise ConnectionError("Failed to connect to QuestDB")
+
                 _cursor = self._connection.cursor()  # type: ignore
 
                 try:

qubx/emitters/base.py

@@ -207,6 +207,6 @@ class BaseMetricEmitter(IMetricEmitter):
         elapsed = current_time - self._last_emission_time
 
         if elapsed >= self._stats_interval:
-            logger.debug(f"[{self.__class__.__name__}] Emitting metrics at {current_time}")
+            # logger.debug(f"[{self.__class__.__name__}] Emitting metrics at {current_time}")
             self.emit_strategy_stats(context)
             self._last_emission_time = current_time

qubx/loggers/__init__.py

@@ -5,9 +5,9 @@ This module provides implementations for logs writing, like csv writer or mongod
 """
 
 from qubx.loggers.csv import CsvFileLogsWriter
+from qubx.loggers.factory import create_logs_writer
 from qubx.loggers.inmemory import InMemoryLogsWriter
 from qubx.loggers.mongo import MongoDBLogsWriter
-from qubx.loggers.factory import create_logs_writer
 
 __all__ = [
     "CsvFileLogsWriter",

qubx/loggers/csv.py

@@ -6,7 +6,8 @@ from multiprocessing.pool import ThreadPool
 
 from qubx import logger
 from qubx.core.loggers import LogsWriter
-from qubx.utils.misc import  makedirs
+from qubx.utils.misc import makedirs
+
 
 class CsvFileLogsWriter(LogsWriter):
     """
@@ -97,4 +98,3 @@ class CsvFileLogsWriter(LogsWriter):
         self._sig_file_.close()
         self.pool.close()
         self.pool.join()
-

qubx/loggers/factory.py

@@ -1,19 +1,19 @@
 import inspect
-
 from typing import Type
 
 from qubx.core.loggers import LogsWriter
 from qubx.loggers.csv import CsvFileLogsWriter
-from qubx.loggers.mongo import MongoDBLogsWriter
 from qubx.loggers.inmemory import InMemoryLogsWriter
+from qubx.loggers.mongo import MongoDBLogsWriter
 
 # Registry of logs writer types
 LOGS_WRITER_REGISTRY: dict[str, Type[LogsWriter]] = {
     "CsvFileLogsWriter": CsvFileLogsWriter,
     "MongoDBLogsWriter": MongoDBLogsWriter,
-    "InMemoryLogsWriter": InMemoryLogsWriter
+    "InMemoryLogsWriter": InMemoryLogsWriter,
 }
 
+
 def create_logs_writer(log_writer_type: str, parameters: dict | None = None) -> LogsWriter:
     """
     Create a logs writer based on configuration.
@@ -30,8 +30,7 @@ def create_logs_writer(log_writer_type: str, parameters: dict | None = None) ->
     """
     if log_writer_type not in LOGS_WRITER_REGISTRY:
         raise ValueError(
-            f"Unknown logs writer type: {log_writer_type}. "
-            f"Available types: {', '.join(LOGS_WRITER_REGISTRY.keys())}"
+            f"Unknown logs writer type: {log_writer_type}. Available types: {', '.join(LOGS_WRITER_REGISTRY.keys())}"
         )
 
     logs_writer_class = LOGS_WRITER_REGISTRY[log_writer_type]
@@ -52,4 +51,4 @@ def register_logs_writer(log_writer_type: str, logs_witer_class: Type[LogsWriter
         log_writer_type: The name of the logs writer type.
         logs_witer_class: The logs writer class to register.
     """
-    LOGS_WRITER_REGISTRY[log_writer_type] = logs_witer_class
+    LOGS_WRITER_REGISTRY[log_writer_type] = logs_witer_class

qubx/loggers/inmemory.py

@@ -1,15 +1,17 @@
-import pandas as pd
+from typing import Any
 
-from typing import Any, Dict, List
+import pandas as pd
 
+from qubx import logger
 from qubx.core.loggers import LogsWriter
 from qubx.core.metrics import split_cumulative_pnl
 from qubx.pandaz.utils import scols
 
+
 class InMemoryLogsWriter(LogsWriter):
-    _portfolio: List
-    _execs: List
-    _signals: List
+    _portfolio: list[dict[str, Any]]
+    _execs: list[dict[str, Any]]
+    _signals: list[dict[str, Any]]
 
     def __init__(self, account_id: str, strategy_id: str, run_id: str) -> None:
         super().__init__(account_id, strategy_id, run_id)
@@ -17,7 +19,7 @@ class InMemoryLogsWriter(LogsWriter):
         self._execs = []
         self._signals = []
 
-    def write_data(self, log_type: str, data: List[Dict[str, Any]]):
+    def write_data(self, log_type: str, data: list[dict[str, Any]]):
         if len(data) > 0:
             if log_type == "portfolio":
                 self._portfolio.extend(data)
@@ -27,31 +29,35 @@ class InMemoryLogsWriter(LogsWriter):
                 self._signals.extend(data)
 
     def get_portfolio(self, as_plain_dataframe=True) -> pd.DataFrame:
-        pfl = pd.DataFrame.from_records(self._portfolio, index="timestamp")
-        pfl.index = pd.DatetimeIndex(pfl.index)
-        if as_plain_dataframe:
-            # - convert to Qube presentation (TODO: temporary)
-            pis = []
-            for s in set(pfl["symbol"]):
-                pi = pfl[pfl["symbol"] == s]
-                pi = pi.drop(columns=["symbol", "realized_pnl_quoted", "current_price", "exchange_time"])
-                pi = pi.rename(
-                    {
-                        "pnl_quoted": "PnL",
-                        "quantity": "Pos",
-                        "avg_position_price": "Price",
-                        "market_value_quoted": "Value",
-                        "commissions_quoted": "Commissions",
-                    },
-                    axis=1,
-                )
-                # We want to convert the value to just price * quantity
-                # in reality value of perps is just the unrealized pnl but
-                # it's not important after simulation for metric calculations
-                pi["Value"] = pi["Pos"] * pi["Price"] + pi["Value"]
-                pis.append(pi.rename(lambda x: s + "_" + x, axis=1))
-            return split_cumulative_pnl(scols(*pis))
-        return pfl
+        try:
+            pfl = pd.DataFrame.from_records(self._portfolio, index="timestamp")
+            pfl.index = pd.DatetimeIndex(pfl.index)
+            if as_plain_dataframe:
+                # - convert to Qube presentation (TODO: temporary)
+                pis = []
+                for s in set(pfl["symbol"]):
+                    pi = pfl[pfl["symbol"] == s]
+                    pi = pi.drop(columns=["symbol", "realized_pnl_quoted", "current_price", "exchange_time"])
+                    pi = pi.rename(
+                        {
+                            "pnl_quoted": "PnL",
+                            "quantity": "Pos",
+                            "avg_position_price": "Price",
+                            "market_value_quoted": "Value",
+                            "commissions_quoted": "Commissions",
+                        },
+                        axis=1,
+                    )
+                    # We want to convert the value to just price * quantity
+                    # in reality value of perps is just the unrealized pnl but
+                    # it's not important after simulation for metric calculations
+                    pi["Value"] = pi["Pos"] * pi["Price"] + pi["Value"]
+                    pis.append(pi.rename(lambda x: s + "_" + x, axis=1))
+                return split_cumulative_pnl(scols(*pis))
+            return pfl
+        except Exception as e:
+            logger.error(f":: Error getting portfolio: {e} ::\n{self._portfolio}")
+            return pd.DataFrame()
 
     def get_executions(self) -> pd.DataFrame:
         p = pd.DataFrame()
@@ -65,4 +71,4 @@ class InMemoryLogsWriter(LogsWriter):
         if self._signals:
             p = pd.DataFrame.from_records(self._signals, index="timestamp")
             p.index = pd.DatetimeIndex(p.index)
-        return p
+        return p

qubx/loggers/mongo.py

@@ -1,7 +1,8 @@
 from datetime import datetime
 from multiprocessing.pool import ThreadPool
+from typing import Any
+
 from pymongo import MongoClient
-from typing import Any, Dict, List
 
 from qubx.core.loggers import LogsWriter
 
@@ -31,25 +32,13 @@ class MongoDBLogsWriter(LogsWriter):
         self.collection_name_prefix = collection_name_prefix
 
         # Ensure TTL index exists on the 'timestamp' field
-        self.db[f"{collection_name_prefix}_positions"].create_index(
-            "timestamp", expireAfterSeconds=ttl_seconds
-        )
-        self.db[f"{collection_name_prefix}_portfolio"].create_index(
-            "timestamp", expireAfterSeconds=ttl_seconds
-        )
-        self.db[f"{collection_name_prefix}_executions"].create_index(
-            "timestamp", expireAfterSeconds=ttl_seconds
-        )
-        self.db[f"{collection_name_prefix}_signals"].create_index(
-            "timestamp", expireAfterSeconds=ttl_seconds
-        )
-        self.db[f"{collection_name_prefix}_balance"].create_index(
-            "timestamp", expireAfterSeconds=ttl_seconds
-        )
-    
-    def _attach_metadata(
-        self, data: List[Dict[str, Any]], log_type: str
-    ) -> List[Dict[str, Any]]:
+        self.db[f"{collection_name_prefix}_positions"].create_index("timestamp", expireAfterSeconds=ttl_seconds)
+        self.db[f"{collection_name_prefix}_portfolio"].create_index("timestamp", expireAfterSeconds=ttl_seconds)
+        self.db[f"{collection_name_prefix}_executions"].create_index("timestamp", expireAfterSeconds=ttl_seconds)
+        self.db[f"{collection_name_prefix}_signals"].create_index("timestamp", expireAfterSeconds=ttl_seconds)
+        self.db[f"{collection_name_prefix}_balance"].create_index("timestamp", expireAfterSeconds=ttl_seconds)
+
+    def _attach_metadata(self, data: list[dict[str, Any]], log_type: str) -> list[dict[str, Any]]:
         now = datetime.utcnow()
         return [
             {
@@ -62,19 +51,25 @@ class MongoDBLogsWriter(LogsWriter):
             }
             for d in data
         ]
-    
-    def _do_write(self, log_type: str, data: List[Dict[str, Any]]):
+
+    def _do_write(self, log_type: str, data: list[dict[str, Any]]):
         docs = self._attach_metadata(data, log_type)
         self.db[f"{self.collection_name_prefix}_{log_type}"].insert_many(docs)
 
-    def write_data(self, log_type: str, data: List[Dict[str, Any]]):
+    def write_data(self, log_type: str, data: list[dict[str, Any]]):
         if len(data) > 0:
-            self.pool.apply_async(self._do_write, (log_type, data,))
-    
+            self.pool.apply_async(
+                self._do_write,
+                (
+                    log_type,
+                    data,
+                ),
+            )
+
     def flush_data(self):
         pass
-    
+
     def close(self):
         self.pool.close()
         self.pool.join()
-        self.client.close()
+        self.client.close()

qubx/notifications/slack.py

@@ -5,6 +5,7 @@ This module provides a Slack implementation of IStrategyLifecycleNotifier.
 """
 
 import datetime
+import threading
 from concurrent.futures import ThreadPoolExecutor
 from typing import Any
 
@@ -52,6 +53,9 @@ class SlackLifecycleNotifier(IStrategyLifecycleNotifier):
         self._emoji_error = emoji_error
         self._throttler = throttler if throttler is not None else NoThrottling()
 
+        # Add a lock for thread-safe throttling operations
+        self._throttler_lock = threading.Lock()
+
         self._executor = ThreadPoolExecutor(max_workers=max_workers, thread_name_prefix="slack_notifier")
 
         logger.info(f"[SlackLifecycleNotifier] Initialized for environment '{environment}'")
@@ -75,10 +79,16 @@ class SlackLifecycleNotifier(IStrategyLifecycleNotifier):
             throttle_key: Optional key for throttling (if None, no throttling is applied)
         """
         try:
-            # Check if the message should be throttled
-            if throttle_key is not None and not self._throttler.should_send(throttle_key):
-                logger.debug(f"[SlackLifecycleNotifier] Throttled message with key '{throttle_key}': {message}")
-                return
+            # Thread-safe throttling check and registration
+            if throttle_key is not None:
+                with self._throttler_lock:
+                    if not self._throttler.should_send(throttle_key):
+                        logger.debug(f"[SlackLifecycleNotifier] Throttled message with key '{throttle_key}': {message}")
+                        return
+                    # Immediately register that we're about to send this message
+                    # This prevents race conditions where multiple threads check should_send
+                    # before any of them call register_sent
+                    self._throttler.register_sent(throttle_key)
 
             # Submit the task to the executor
             self._executor.submit(self._post_to_slack_impl, message, emoji, color, metadata, throttle_key)
@@ -132,10 +142,6 @@ class SlackLifecycleNotifier(IStrategyLifecycleNotifier):
             response = requests.post(self._webhook_url, json=data)
             response.raise_for_status()
 
-            # Register that we sent the message (for throttling)
-            if throttle_key is not None:
-                self._throttler.register_sent(throttle_key)
-
             logger.debug(f"[SlackLifecycleNotifier] Successfully posted message: {message}")
             return True
         except requests.RequestException as e:

qubx/restarts/state_resolvers.py

@@ -55,7 +55,7 @@ class StateResolver:
                 elif abs(live_qty) > abs(sim_qty) and abs(live_qty) > instrument.lot_size:
                     qty_diff = sim_qty - live_qty
                     logger.info(
-                        f"Reducing position for {instrument.symbol}: {live_qty} -> {sim_qty} (diff: {qty_diff})"
+                        f"Reducing position for {instrument.symbol}: {live_qty} -> {sim_qty} (diff: {qty_diff:.4f})"
                     )
                     ctx.trade(instrument, qty_diff)
 
@@ -123,7 +123,7 @@ class StateResolver:
             # Only trade if there's a difference
             if abs(qty_diff) > instrument.lot_size:
                 logger.info(
-                    f"Syncing position for {instrument.symbol}: {live_qty} -> {sim_pos.quantity} (diff: {qty_diff})"
+                    f"Syncing position for {instrument.symbol}: {live_qty} -> {sim_pos.quantity} (diff: {qty_diff:.4f})"
                 )
                 ctx.trade(instrument, qty_diff)
 

qubx/restorers/signal.py

@@ -208,31 +208,10 @@ class MongoDBSignalRestorer(ISignalRestorer):
             A dictionary mapping instruments to lists of signals.
         """
         try:
-            now = datetime.utcnow()
-            lookup_range = now - timedelta(days=30)
-            base_match = {
-                "log_type": "signals",
-                "strategy_name": self.strategy_name,
-                "timestamp": {"$gte": lookup_range}
-            }
-
-            latest_run_doc = (
-                self.collection.find(base_match, {"run_id": 1, "timestamp": 1})
-                .sort("timestamp", -1)
-                .limit(1)
-            )
-
-            latest_run = next(latest_run_doc, None)
-            if not latest_run:
-                logger.warning("No signal logs found for given filters.")
-                return {}
-
-            latest_run_id = latest_run["run_id"]
-
-            logger.info(f"Restoring signals from MongoDB for run_id: {latest_run_id}")
+            logger.info(f"Restoring latest 20 signals per symbol from MongoDB")
 
             pipeline = [
-                {"$match": {"log_type": "signals", "strategy_name": self.strategy_name, "run_id": latest_run_id}},
+                {"$match": {"log_type": "signals", "strategy_name": self.strategy_name}},
                 {"$sort": {"timestamp": -1}},
                 {
                     "$group": {

qubx/utils/runner/configs.py

@@ -103,6 +103,7 @@ class SimulationConfig(BaseModel):
     n_jobs: int | None = None
     variate: dict = Field(default_factory=dict)
     debug: str | None = None
+    run_separate_instruments: bool = False
 
 
 class StrategyConfig(BaseModel):

qubx/utils/runner/factory.py

@@ -44,13 +44,16 @@ def construct_reader(reader_config: ReaderConfig | None) -> DataReader | None:
         raise
 
 
-def create_metric_emitters(emission_config: EmissionConfig, strategy_name: str) -> IMetricEmitter | None:
+def create_metric_emitters(
+    emission_config: EmissionConfig, strategy_name: str, run_id: str | None = None
+) -> IMetricEmitter | None:
     """
     Create metric emitters from the configuration.
 
     Args:
         emission_config: Configuration for metric emission
         strategy_name: Name of the strategy to be included in tags
+        run_id: Optional run ID to be included in tags
 
     Returns:
         IMetricEmitter or None if no metric emitters are configured
@@ -97,6 +100,8 @@ def create_metric_emitters(emission_config: EmissionConfig, strategy_name: str)
                 tags[k] = resolve_env_vars(v)
 
             tags["strategy"] = strategy_name
+            if run_id is not None:
+                tags["run_id"] = run_id
 
             # Add tags if the emitter supports it
             if "tags" in inspect.signature(emitter_class).parameters:
@@ -181,9 +186,9 @@ def create_data_type_readers(readers_configs: list[TypedReaderConfig] | None) ->
 
 
 def create_exporters(
-        exporters: list[ExporterConfig] | None, 
-        strategy_name: str,
-        account: Optional[IAccountViewer] = None,
+    exporters: list[ExporterConfig] | None,
+    strategy_name: str,
+    account: Optional[IAccountViewer] = None,
 ) -> ITradeDataExport | None:
     """
     Create exporters from the configuration.
@@ -293,7 +298,9 @@ def create_lifecycle_notifiers(
                 params[key] = resolve_env_vars(value)
 
             # Create throttler if configured or use default TimeWindowThrottler
-            if "SlackLifecycleNotifier" in notifier_class_name and "throttler" not in params:
+            if "SlackLifecycleNotifier" in notifier_class_name and (
+                "throttle" not in params or params["throttle"] is None
+            ):
                 # Import here to avoid circular imports
                 from qubx.notifications.throttler import TimeWindowThrottler
 

qubx/utils/runner/runner.py

@@ -28,6 +28,7 @@ from qubx.core.basics import (
     CtrlChannel,
     Instrument,
     LiveTimeProvider,
+    Position,
     RestoredState,
     TransactionCostsCalculator,
 )
@@ -263,6 +264,9 @@ def create_strategy_context(
     stg_name = _get_strategy_name(config)
     _run_mode = "paper" if paper else "live"
 
+    # Generate run_id once to be shared between logging and metric emissions
+    run_id = f"{socket.gethostname()}-{str(int(time.time() * 10**9))}"
+
     if isinstance(config.strategy, list):
         _strategy_class = reduce(lambda x, y: x + y, [class_import(x) for x in config.strategy])
     elif isinstance(config.strategy, str):
@@ -270,12 +274,12 @@ def create_strategy_context(
     else:
         _strategy_class = config.strategy
 
-    _logging = _setup_strategy_logging(stg_name, config.live.logging, simulated_formatter, no_color)
+    _logging = _setup_strategy_logging(stg_name, config.live.logging, simulated_formatter, run_id)
 
     _aux_reader = construct_reader(config.aux) if config.aux else None
 
-    # Create metric emitters
-    _metric_emitter = create_metric_emitters(config.live.emission, stg_name) if config.live.emission else None
+    # Create metric emitters with run_id as a tag
+    _metric_emitter = create_metric_emitters(config.live.emission, stg_name, run_id) if config.live.emission else None
 
     # Create lifecycle notifiers
     _lifecycle_notifier = create_lifecycle_notifiers(config.live.notifiers, stg_name) if config.live.notifiers else None
@@ -387,7 +391,10 @@ def _get_strategy_name(cfg: StrategyConfig) -> str:
 
 
 def _setup_strategy_logging(
-    stg_name: str, log_config: LoggingConfig, simulated_formatter: SimulatedLogFormatter, no_color: bool = False
+    stg_name: str,
+    log_config: LoggingConfig,
+    simulated_formatter: SimulatedLogFormatter,
+    run_id: str,
 ) -> StrategyLogging:
     if not hasattr(log_config, "args") or not isinstance(log_config.args, dict):
         log_config.args = {}
@@ -402,8 +409,6 @@ def _setup_strategy_logging(
         level=QubxLogConfig.get_log_level(),
     )
 
-    run_id = f"{socket.gethostname()}-{str(int(time.time() * 10**9))}"
-
     _log_writer_name = log_config.logger
 
     logger.debug(f"Setup <g>{_log_writer_name}</g> logger...")
@@ -691,6 +696,14 @@ def _run_warmup(
         if o.instrument in _instruments:
             instrument_to_orders[o.instrument].append(o)
 
+    # - find instruments with nonzero positions from restored state and add them to the context
+    if restored_state is not None:
+        restored_positions = {k: p for k, p in restored_state.positions.items() if p.is_open()}
+        # - if there is no warmup position for a restored position, then create a new zero position
+        for pos in restored_positions.values():
+            if pos.instrument not in _positions:
+                _positions[pos.instrument] = Position(pos.instrument)
+
     # - set the warmup positions and orders
     ctx.set_warmup_positions(_positions)
     ctx.set_warmup_orders(instrument_to_orders)
@@ -737,6 +750,9 @@ def simulate_strategy(
     if cfg.simulation is None:
         raise ValueError("Simulation configuration is required")
 
+    if cfg.simulation.run_separate_instruments and cfg.simulation.variate:
+        raise ValueError("Run separate instruments is not supported with variate")
+
     stg = cfg.strategy
     simulation_name = config_file.stem
     _v_id = pd.Timestamp("now").strftime("%Y%m%d%H%M%S")
@@ -759,6 +775,11 @@ def simulate_strategy(
             for a, c in cond.items():
                 conditions.append(dict2lambda(a, c))
 
+        # - if a parameter is of type list, then transform it to list of lists to avoid invalid variation
+        for k, v in cfg.parameters.items():
+            if isinstance(v, list):
+                cfg.parameters[k] = [v]
+
         experiments = variate(stg_cls, **(cfg.parameters | cfg.simulation.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.")
@@ -790,10 +811,17 @@ def simulate_strategy(
         sim_params["stop"] = stop
         logger.info(f"Stop date set to {stop}")
 
+    if cfg.simulation.n_jobs is not None:
+        sim_params["n_jobs"] = cfg.simulation.n_jobs
+
     # - check for aux_data parameter
     if cfg.aux is not None:
         sim_params["aux_data"] = construct_reader(cfg.aux)
 
+    # - add run_separate_instruments parameter
+    if cfg.simulation.run_separate_instruments:
+        sim_params["run_separate_instruments"] = True
+
     # - run simulation
     print(f" > Run simulation for [{red(simulation_name)}] ::: {sim_params['start']} - {sim_params['stop']}")
     sim_params["n_jobs"] = sim_params.get("n_jobs", _n_jobs)

{qubx-0.6.49.dist-info → qubx-0.6.52.dist-info}/METADATA

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

{qubx-0.6.49.dist-info → qubx-0.6.52.dist-info}/RECORD

@@ -3,15 +3,15 @@ qubx/_nb_magic.py,sha256=G3LkaX_-gN5Js6xl7rjaahSs_u3dVPDRCZW0IIxPCb0,3051
 qubx/backtester/__init__.py,sha256=OhXhLmj2x6sp6k16wm5IPATvv-E2qRZVIcvttxqPgcg,176
 qubx/backtester/account.py,sha256=0yvE06icSeK2ymovvaKkuftY8Ou3Z7Y2JrDa6VtkINw,3048
 qubx/backtester/broker.py,sha256=JMasxycLqCT99NxN50uyQ1uxtpHYL0wpp4sJ3hB6v2M,2688
-qubx/backtester/data.py,sha256=De2ioNv3Zh-cCGakzK0igb2caDcqbibZ_tsYmF7sTTQ,6601
+qubx/backtester/data.py,sha256=B1VHioLqBwA6ZnEgTn5Gere1vfOw0KvyFjGwm4vlByQ,6675
 qubx/backtester/management.py,sha256=HuyzFsBPgR7j-ei78Ngcx34CeSn65c9atmaii1aTsYg,14900
 qubx/backtester/ome.py,sha256=BC8EuJkPTiGbl8HliHehVzwdD0OSDlR04g6RVA66FQE,18614
 qubx/backtester/optimization.py,sha256=HHUIYA6Y66rcOXoePWFOuOVX9iaHGKV0bGt_4d5e6FM,7619
 qubx/backtester/runner.py,sha256=TnNM0t8PgBE_gnCOZZTIOc28a3RqtXmp2Xj4Gq5j6bo,20504
 qubx/backtester/simulated_data.py,sha256=niujaMRj__jf4IyzCZrSBR5ZoH1VUbvsZHSewHftdmI,17240
 qubx/backtester/simulated_exchange.py,sha256=Xg0yv21gq4q9CeCeZoupcenNEBORrxpb93ONZEGL2xk,8076
-qubx/backtester/simulator.py,sha256=cSbW42X-YlAutZlOQ3Y4mAJWXr_1WomYprtWZVMe3Uk,9225
-qubx/backtester/utils.py,sha256=dDaS7Wrc_xZXWuAqKDql7L3NRMvUkTxpuuAwS0SYA1c,32721
+qubx/backtester/simulator.py,sha256=rBDV6Ftq8ProK-VOkewtdhAcM0-kkvv3KTszB-uHdrY,11154
+qubx/backtester/utils.py,sha256=E7_MQhDGXXvFyjt0VSFZiQrNqP02fBml9AC93b6WxZs,34760
 qubx/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubx/cli/commands.py,sha256=MdiBGb8Z3mAFDq44Dn4EuSQRk2aArIrfo1GJ-VwgeQQ,8197
 qubx/cli/deploy.py,sha256=pQ9FPOsywDyy8jOjLfrgYTTkKQ-MCixCzbgsG68Q3_0,8319
@@ -44,31 +44,31 @@ qubx/core/exceptions.py,sha256=11wQC3nnNLsl80zBqbE6xiKCqm31kctqo6W_gdnZkg8,581
 qubx/core/helpers.py,sha256=m7JrZaBckXHb4zjhKpdCbxFe3kfda-SCNLfagyq7Ve4,19158
 qubx/core/initializer.py,sha256=YgTBs5LpIk6ZFdmMD8zCnJnVNcMh1oeYvt157jhwyMg,4242
 qubx/core/interfaces.py,sha256=gwitvNSni2zUWdpcRyqAdw9n3l1-Z6TBvl9D--hIqgM,59104
-qubx/core/loggers.py,sha256=0g33jfipGFShSMrXBoYVzL0GfTzI36mwBJqHNUHmhdo,13342
+qubx/core/loggers.py,sha256=85Xgt1-Hh-2gAlJez3TxTHr32KSWYNqNhmbeWZwhw0o,13340
 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=cmjD0PcQv3gFP6oILfNgdNgw7Tez0fUZu_nFn6680VI,24979
+qubx/core/mixins/processing.py,sha256=VEaK6ZjXTa8jvavj_VpCYfGvLFTHpNoL1AKdRAeear8,27394
 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=V8Hs9I9gxSCftWlaVepjlIyAji7R_99OyjlincaOBpU,9758
-qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=qr_Kp48TninYcwnu3KCh6A09j-IBn9pChO_AO2IfKb0,978280
+qubx/core/mixins/universe.py,sha256=tsMpBriLHwK9lAVYvIrO94EIx8_ETSXUlzxN_sDOsL8,9838
+qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=SpozS5G2UEoeCbgVsaorjvwbKo5U4d5EqxP3pSktzyM,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=75SE7kvxEyS7dtCgUQ5_mdOs2uXBdoo3APlhRGldQFg,86568
+qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=c3ZAL_JGRFpOPUlSITmuQ_jjxv4bA1CQAV9c13wtUfI,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=bcFJzIzR2-IfVW8Ot3cUibKS8smnmRbHipd8ztIuScs,18015
+qubx/data/composite.py,sha256=l1FjJ2RnX7pxhah-cDBw7CWQQvwqKBCANXKiHRrZBzc,18233
 qubx/data/helpers.py,sha256=VcXBl1kfWzAOqrjadKrP9WemGjJIB0q3xascbesErh4,16268
 qubx/data/hft.py,sha256=be7AwzTOjqqCENn0ClrZoHDyKv3SFG66IyTp8QadHlM,33687
-qubx/data/readers.py,sha256=nSmkH6X-O1uuDVO3dVC47k46etIO-SLvGp0lGfI8pYE,65994
+qubx/data/readers.py,sha256=g3hSkyKdMAVziMCgcaZadsukidECaLwHyIEtArSVDSc,66203
 qubx/data/registry.py,sha256=45mjy5maBSO6cf-0zfIRRDs8b0VDW7wHSPn43aRjv-o,3883
 qubx/data/tardis.py,sha256=O-zglpusmO6vCY3arSOgH6KUbkfPajSAIQfMKlVmh_E,33878
 qubx/emitters/__init__.py,sha256=tpJ9OoW-gycTBXGJ0647tT8-dVBmq23T2wMX_kmk3nM,565
-qubx/emitters/base.py,sha256=eo5yD2402oNVndhNwFspIzB-gZMrZtLRx63JvivdC8Q,7974
+qubx/emitters/base.py,sha256=os69vCs00eRELZn-1TYR7MZXJbnrFOfeW4UEtMLCphw,7976
 qubx/emitters/composite.py,sha256=8DsPIUtaJ95Oww9QTVVB6LR7Wcb6TJ-c1jIHMGuttz4,2784
 qubx/emitters/csv.py,sha256=lWl6sP0ke0j6kVlEbQsy11vSOHFudYHjWS9iPbq6kmo,3067
 qubx/emitters/prometheus.py,sha256=g2hgcV_G77fWVEXtoGJTUs4JLkB2FQXFzVY_x_sEBfc,8100
@@ -90,16 +90,16 @@ qubx/features/utils.py,sha256=5wMlfH4x1dUh00dxvtnHhSiHeRaiod4VMTcmgm-o_wA,264
 qubx/gathering/simplest.py,sha256=24SIjsCfutuTinSW5zSkPHGJvl-vnyhe3FAX3quUx4E,4011
 qubx/health/__init__.py,sha256=ThJTgf-CPD5tMU_emqANpnE6oXfUmzyyugfbDfzeVB0,111
 qubx/health/base.py,sha256=FmpZ7l_L-wJ8JCQ42uRjng3hAbhfmAf3nIUc4vSs9cI,27622
-qubx/loggers/__init__.py,sha256=HY26weGv_qI-i5NrvXepGCwXENOIeORW9uhvyFMVMcM,443
-qubx/loggers/csv.py,sha256=95JLFz2yxo_OjSG21cmWVYZP1XuN3V0FXNPUB_q6ucY,3791
-qubx/loggers/factory.py,sha256=09ahIIQU_59vI4OO1rKYLAHgBbZ2506wv0FqYie_Rb0,1805
-qubx/loggers/inmemory.py,sha256=49Y-jsRxDzBLWQdQMIKjVTvnx_79EbjFpHwj3v8Mgno,2642
-qubx/loggers/mongo.py,sha256=dOEpCcIxT6O9MgpK2srpzxyuto6QaQgTxMK0WcEIR70,2703
+qubx/loggers/__init__.py,sha256=nA7nLQKkR9hIJCYQyZxikm--xsB6DaTE5itKypEPBKA,443
+qubx/loggers/csv.py,sha256=toihEqLtv_TuaMNmrQej9hmikijG4bM8X1du3QP6w4k,3790
+qubx/loggers/factory.py,sha256=pDwLuFPPpoCCTiVoDrzvcAsyPFm6sS0e4Zi3j5UEhqk,1791
+qubx/loggers/inmemory.py,sha256=5BcvEGLxwVD6u3c1eqsO2AVdWZawjJ8A-tJ-OCzzj5M,2965
+qubx/loggers/mongo.py,sha256=yfCq29kIHdn1a6nDA6TKlc-yQpZ54mvbaZ0AmzY9Ydg,2658
 qubx/math/__init__.py,sha256=ltHSQj40sCBm3owcvtoZp34h6ws7pZCFcSZgUkTsUCY,114
 qubx/math/stats.py,sha256=uXm4NpBRxuHFTjXERv8rjM0MAJof8zr1Cklyra4CcBA,4056
 qubx/notifications/__init__.py,sha256=cb3DGxuiA8UwSTlTeF5pQKy4-vBef3gMeKtfcxEjdN4,547
 qubx/notifications/composite.py,sha256=fa-rvHEn6k-Fma5N7cT-7Sk7hzVyB0KDs2ktDyoyLxM,2689
-qubx/notifications/slack.py,sha256=FZ0zfTA-zRHOsOsIVBtM7mkt4m-adiuiV5yrwliS9RM,7976
+qubx/notifications/slack.py,sha256=RWsLyL4lm6tbmrTlXQo3nPlfiLVJ0vCfY5toJ9G8RWU,8316
 qubx/notifications/throttler.py,sha256=8jnymPQbrgtN1rD7REQa2sA9teSWTqkk_uT9oaknOyc,5618
 qubx/pandaz/__init__.py,sha256=6BYz6gSgxjNa7WP1XqWflYG7WIq1ppSD9h1XGR5M5YQ,682
 qubx/pandaz/ta.py,sha256=sIX9YxxB2S2nWU4vnS4rXFuEI5WSY76Ky1TFwf9RhMw,92154
@@ -113,18 +113,18 @@ 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/restarts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qubx/restarts/state_resolvers.py,sha256=GJ617qwpulqMp_-WhpmsLozQobxgt5lU4ZGOIUaUzas,5606
+qubx/restarts/state_resolvers.py,sha256=xzQEFPGbYFYShSSb0cB3RvWl-8npRau_HrrMgTccSc0,5614
 qubx/restarts/time_finders.py,sha256=r7yyRhJByV2uqdgamDRX2XClwpWWI9BNpc80t9nk6c0,2448
 qubx/restorers/__init__.py,sha256=vrnZBPJHR0-6knAccj4bK0tkjUPNRl32qiLr5Mv4aR0,911
 qubx/restorers/balance.py,sha256=yLV1vBki0XhBxrOhgaJBHuuL8VmIii82LAWgLxusbcE,6967
 qubx/restorers/factory.py,sha256=eoijcUHDaBVPHSfkjyo1AHvWTvvs0kj7jJbF_NE30aw,6737
 qubx/restorers/interfaces.py,sha256=CcjBWavKq8_GIMKTSPodMa-n3wJQwcQTwyvYyNo_J3c,1776
 qubx/restorers/position.py,sha256=jMJjq2ZJwHpAlG45bMy49WvkYK5UylDiExt7nVpxCfg,8703
-qubx/restorers/signal.py,sha256=x-VLSnb863U517sPeZhGvfuIOUfmYVhANg5P7lio_Mg,11630
+qubx/restorers/signal.py,sha256=0QFoy7OzDkK6AAmJEbbmSsHwmAhjMJYYggVFuLraKjk,10899
 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=eci5pBLi6C5wdeMg8XaDZetvc5KOGai0J7B8X5uhuSs,654440
+qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=PwEMehN97zxTw_faYmjrDUHu_8-QlfsjOxo3h7bPQKo,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
@@ -156,13 +156,13 @@ qubx/utils/questdb.py,sha256=TdjmlGPoZXdjidZ_evcBIkFtoL4nGQXPR4IQSUc6IvA,2509
 qubx/utils/runner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubx/utils/runner/_jupyter_runner.pyt,sha256=fDj4AUs25jsdGmY9DDeSFufH1JkVhLFwy0BOmVO7nIU,9609
 qubx/utils/runner/accounts.py,sha256=mpiv6oxr5z97zWt7STYyARMhWQIpc_XFKungb_pX38U,3270
-qubx/utils/runner/configs.py,sha256=CtNXX0Ycnv4zeyqYVpr3i_2rK21jqYuzJcqM_m75x2U,3670
-qubx/utils/runner/factory.py,sha256=8IxKvsEL0opx5OlO4XEQgAlmu05sgxXxkY4G2MQdLbg,14941
-qubx/utils/runner/runner.py,sha256=iL929cwv75sSIBREWxTj4gG5mImn0qG2bX-9ck3ryY4,30152
+qubx/utils/runner/configs.py,sha256=snVZJun6rBC09QZVaUd7BhqNlDZqmDMG7R8gHJeuSkU,3713
+qubx/utils/runner/factory.py,sha256=eM4-Etcq-FewD2AjH_srFGzP413pm8er95KIZixXRpM,15152
+qubx/utils/runner/runner.py,sha256=9s7mu84U29jCE7FtdW_yKKTzQfaXmCSvANF5cb7xd_Y,31399
 qubx/utils/time.py,sha256=J0ZFGjzFL5T6GA8RPAel8hKG0sg2LZXeQ5YfDCfcMHA,10055
 qubx/utils/version.py,sha256=e52fIHyxzCiIuH7svCF6pkHuDlqL64rklqz-2XjWons,5309
-qubx-0.6.49.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
-qubx-0.6.49.dist-info/METADATA,sha256=ohYiVM7Tgtzai41K_bOb-vO3Ka-EakDzmSA40RlVfYY,4612
-qubx-0.6.49.dist-info/WHEEL,sha256=UckHTmFUCaLKpi4yFY8Dewu0c6XkY-KvEAGzGOnaWo8,110
-qubx-0.6.49.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
-qubx-0.6.49.dist-info/RECORD,,
+qubx-0.6.52.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
+qubx-0.6.52.dist-info/METADATA,sha256=Hor3x6zOv1rKp_mKkMdFc6HqE5bWIh14oHlX8ignRLk,4612
+qubx-0.6.52.dist-info/WHEEL,sha256=UckHTmFUCaLKpi4yFY8Dewu0c6XkY-KvEAGzGOnaWo8,110
+qubx-0.6.52.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
+qubx-0.6.52.dist-info/RECORD,,