Qubx 0.6.38__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.41__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/_nb_magic.py

@@ -53,6 +53,7 @@ if runtime_env() in ["notebook", "shell"]:
     from qubx.core.metrics import (  # noqa: F401
         chart_signals,
         drop_symbols,
+        extend_trading_results,
         get_symbol_pnls,
         pick_symbols,
         pnl,

qubx/backtester/simulated_exchange.py

@@ -155,9 +155,7 @@ class BasicSimulatedExchange(ISimulatedExchange):
                     if order.id == order_id:
                         return self._process_ome_response(o.cancel_order(order_id))
 
-            logger.error(
-                f"[<y>{self.__class__.__name__}</y>] :: cancel_order :: can't find order with id = 'ValueError{order_id}'!"
-            )
+            logger.warning(f"[<y>{self.__class__.__name__}</y>] :: cancel_order :: can't find order '{order_id}'!")
             return None
 
         ome = self._ome.get(instrument)

qubx/cli/deploy.py

@@ -182,6 +182,29 @@ def setup_poetry_environment(output_dir: str) -> bool:
         return False
 
 
+def create_strategy_runners(output_dir: str):
+    """
+    Creates a strategy runner script in the output_dir
+    """
+    import sys
+
+    if sys.platform == "win32":
+        _pfx = ""
+        _f_name = os.path.join(output_dir, "run_paper.bat")
+    else:
+        _pfx = "#!/bin/bash\n"
+        _f_name = os.path.join(output_dir, "run_paper.sh")
+
+    logger.info(f"Creating strategy paper runner script: {_f_name}")
+
+    try:
+        with open(_f_name, "w") as f:
+            f.write(f"{_pfx}poetry run qubx run config.yml --paper -j")
+        os.chmod(_f_name, 0o755)
+    except Exception as e:
+        logger.error(f"Failed to create strategy paper runner script: {e}")
+
+
 def deploy_strategy(zip_file: str, output_dir: str | None, force: bool) -> bool:
     """
     Deploys a strategy from a zip file created by the release command.
@@ -222,9 +245,10 @@ def deploy_strategy(zip_file: str, output_dir: str | None, force: bool) -> bool:
     if not setup_poetry_environment(resolved_output_dir):
         return False
 
+    # Create the strategy runners
+    create_strategy_runners(resolved_output_dir)
+
     # Success messages
     logger.info(f"Strategy deployed successfully to {resolved_output_dir}")
-    logger.info(
-        f"To run the strategy (paper mode): <cyan>cd {resolved_output_dir} && poetry run qubx run config.yml --paper</cyan>"
-    )
+    logger.info(f" -> To run the strategy (in paper mode): <cyan>cd {resolved_output_dir} && ./run_paper.sh</cyan>")
     return True

qubx/core/helpers.py

@@ -20,7 +20,7 @@ from qubx.utils.time import convert_seconds_to_str, convert_tf_str_td64, interva
 
 class CachedMarketDataHolder:
     """
-    Collected cached data updates from StrategyContext
+    Collected cached data updates from market
     """
 
     default_timeframe: np.timedelta64
@@ -35,7 +35,6 @@ class CachedMarketDataHolder:
         self._last_bar = defaultdict(lambda: None)
         self._updates = dict()
         self._instr_to_sub_to_buffer = defaultdict(lambda: defaultdict(lambda: deque(maxlen=max_buffer_size)))
-        self._ready_instruments = set()
         if default_timeframe:
             self.update_default_timeframe(default_timeframe)
 
@@ -68,19 +67,8 @@ class CachedMarketDataHolder:
         self._ohlcvs = other._ohlcvs
         self._updates = other._updates
         self._instr_to_sub_to_buffer = other._instr_to_sub_to_buffer
-        self._ready_instruments = set()  # reset the ready instruments
         self._last_bar = defaultdict(lambda: None)  # reset the last bar
 
-    def is_data_ready(self) -> bool:
-        """
-        Check if at least one update was received for all instruments.
-        """
-        # Check if we have at least one update for each instrument
-        if not self._ohlcvs:
-            return False
-
-        return all(instrument in self._ready_instruments for instrument in self._ohlcvs)
-
     @SW.watch("CachedMarketDataHolder")
     def get_ohlcv(self, instrument: Instrument, timeframe: str | None = None, max_size: float | int = np.inf) -> OHLCV:
         tf = convert_tf_str_td64(timeframe) if timeframe else self.default_timeframe
@@ -121,9 +109,6 @@ class CachedMarketDataHolder:
         if event_type != DataType.OHLC:
             self._instr_to_sub_to_buffer[instrument][event_type].append(data)
 
-        if not is_historical and is_base_data:
-            self._ready_instruments.add(instrument)
-
         if not update_ohlc:
             return
 

qubx/core/metrics.py

@@ -21,7 +21,7 @@ from statsmodels.regression.linear_model import OLS
 from qubx import logger
 from qubx.core.basics import Instrument
 from qubx.core.series import OHLCV
-from qubx.pandaz.utils import ohlc_resample
+from qubx.pandaz.utils import ohlc_resample, srows
 from qubx.utils.charting.lookinglass import LookingGlass
 from qubx.utils.charting.mpl_helpers import sbp
 from qubx.utils.misc import makedirs, version
@@ -884,7 +884,7 @@ class TradingSessionResult:
         _perf = info.pop("performance", None)
         info["instruments"] = info.pop("symbols")
         # - fix for old versions
-        _exch = info.pop("exchange")
+        _exch = info.pop("exchange") if "exchange" in info else info.pop("exchanges")
         info["exchanges"] = _exch if isinstance(_exch, list) else [_exch]
         tsr = TradingSessionResult(**info, portfolio_log=portfolio, executions_log=executions, signals_log=signals)
         tsr.qubx_version = _qbx_version
@@ -1500,6 +1500,9 @@ def get_symbol_pnls(
 
 
 def combine_sessions(sessions: list[TradingSessionResult], name: str = "Portfolio") -> TradingSessionResult:
+    """
+    DEPRECATED: use extend_trading_results instead
+    """
     session = copy(sessions[0])
     session.name = name
     session.instruments = list(set(chain.from_iterable([e.instruments for e in sessions])))
@@ -1518,6 +1521,45 @@ def combine_sessions(sessions: list[TradingSessionResult], name: str = "Portfoli
     return session
 
 
+def extend_trading_results(results: list[TradingSessionResult]) -> TradingSessionResult:
+    """
+    Combine multiple trading session results into a single result by extending the sessions.
+    """
+    import os
+
+    pfls, execs, exch, names, instrs, clss = [], [], [], [], [], []
+    cap = 0.0
+
+    for b in sorted(results, key=lambda x: x.start):
+        pfls.append(b.portfolio_log)
+        execs.append(b.executions_log)
+        exch.extend(b.exchanges)
+        names.append(b.name)
+        cap += b.capital if isinstance(b.capital, float) else 0.0  # TODO: add handling dict
+        instrs.extend(b.instruments)
+        clss.append(b.strategy_class)
+    cmn = os.path.commonprefix(names)
+    names = [x[len(cmn) :] for x in names]
+    f_pfls: pd.DataFrame = srows(*pfls, keep="last")  # type: ignore
+    f_execs: pd.DataFrame = srows(*execs, keep="last")  # type: ignore
+    r = TradingSessionResult(
+        0,
+        cmn + "-".join(names),
+        start=f_pfls.index[0],
+        stop=f_pfls.index[-1],
+        exchanges=list(set(exch)),
+        capital=cap / len(results),  # average capital ???
+        instruments=list(set(instrs)),
+        base_currency=results[0].base_currency,
+        commissions=results[0].commissions,  # what if different commissions ???
+        portfolio_log=f_pfls,
+        executions_log=f_execs,
+        signals_log=pd.DataFrame(),
+        strategy_class="-".join(set(clss)),  # what if different strategy classes ???
+    )
+    return r
+
+
 def _plt_to_base64() -> str:
     fig = plt.gcf()
 

qubx/core/mixins/processing.py

@@ -66,6 +66,7 @@ class ProcessingManager(IProcessingManager):
     _pool: ThreadPool | None
     _trig_bar_freq_nsec: int | None = None
     _cur_sim_step: int | None = None
+    _updated_instruments: set[Instrument] = set()
 
     def __init__(
         self,
@@ -109,6 +110,7 @@ class ProcessingManager(IProcessingManager):
         }
         self._strategy_name = strategy.__class__.__name__
         self._trig_bar_freq_nsec = None
+        self._updated_instruments = set()
 
     def set_fit_schedule(self, schedule: str) -> None:
         rule = process_schedule_spec(schedule)
@@ -340,6 +342,12 @@ class ProcessingManager(IProcessingManager):
             _d_probe,
         )
 
+    def _is_data_ready(self) -> bool:
+        """
+        Check if at least one update was received for all instruments in the context.
+        """
+        return all(instrument in self._updated_instruments for instrument in self._context.instruments)
+
     def __update_base_data(
         self, instrument: Instrument, event_type: str, data: Timestamped, is_historical: bool = False
     ) -> bool:
@@ -366,6 +374,9 @@ class ProcessingManager(IProcessingManager):
         # update trackers, gatherers on base data
         if not is_historical:
             if is_base_data:
+                # - mark instrument as updated
+                self._updated_instruments.add(instrument)
+
                 self._account.update_position_price(self._time_provider.time(), instrument, _update)
                 target_positions = self.__process_and_log_target_positions(
                     self._position_tracker.update(self._context, instrument, _update)
@@ -421,13 +432,13 @@ class ProcessingManager(IProcessingManager):
         pass
 
     def _handle_start(self) -> None:
-        if not self._cache.is_data_ready():
+        if not self._is_data_ready():
             return
         self._strategy.on_start(self._context)
         self._context._strategy_state.is_on_start_called = True
 
     def _handle_state_resolution(self) -> None:
-        if not self._cache.is_data_ready():
+        if not self._is_data_ready():
             return
 
         resolver = self._context.initializer.get_state_resolver()
@@ -448,7 +459,7 @@ class ProcessingManager(IProcessingManager):
         resolver(self._context, self._context.get_warmup_positions(), self._context.get_warmup_orders())
 
     def _handle_warmup_finished(self) -> None:
-        if not self._cache.is_data_ready():
+        if not self._is_data_ready():
             return
         self._strategy.on_warmup_finished(self._context)
         self._context._strategy_state.is_on_warmup_finished_called = True
@@ -457,7 +468,7 @@ class ProcessingManager(IProcessingManager):
         """
         When scheduled fit event is happened - we need to invoke strategy on_fit method
         """
-        if not self._cache.is_data_ready():
+        if not self._is_data_ready():
             return
         self._fit_is_running = True
         self._run_in_thread_pool(self.__invoke_on_fit)

qubx/data/tardis.py

@@ -81,21 +81,25 @@ class TardisCsvDataReader(DataReader):
         _filt_files = [file for file in _files if t_0 <= file.stem.split("_")[0] <= t_1]
 
         tables = []
-        fieldnames = None
+        # fieldnames = None
         for f_path in _filt_files:
-            table = csv.read_csv(
-                f_path,
-                parse_options=csv.ParseOptions(ignore_empty_lines=True),
-            )
-            if not fieldnames:
-                fieldnames = table.column_names
-            tables.append(table.to_pandas())
-
-        transform.start_transform(data_id, fieldnames or [], start=start, stop=stop)
-        raw_data = pd.concat(tables).to_numpy()
-        transform.process_data(raw_data)
-
-        return transform.collect()
+            table = pd.read_csv(f_path)
+            tables.append(table)
+            # table = csv.read_csv(
+            #     f_path,
+            #     parse_options=csv.ParseOptions(ignore_empty_lines=True),
+            # )
+            # if not fieldnames:
+            #     fieldnames = table.column_names
+            # tables.append(table.to_pandas())
+
+        return pd.concat(tables)
+
+        # transform.start_transform(data_id, fieldnames or [], start=start, stop=stop)
+        # raw_data = pd.concat(tables).to_numpy()
+        # transform.process_data(raw_data)
+
+        # return transform.collect()
 
     def get_exchanges(self) -> list[str]:
         return [exchange.name for exchange in self.path.iterdir() if exchange.is_dir()]

qubx/notifications/__init__.py

@@ -7,5 +7,13 @@ for various notification channels.
 
 from .composite import CompositeLifecycleNotifier
 from .slack import SlackLifecycleNotifier
+from .throttler import CountBasedThrottler, IMessageThrottler, NoThrottling, TimeWindowThrottler
 
-__all__ = ["CompositeLifecycleNotifier", "SlackLifecycleNotifier"]
+__all__ = [
+    "CompositeLifecycleNotifier", 
+    "SlackLifecycleNotifier",
+    "IMessageThrottler",
+    "TimeWindowThrottler",
+    "CountBasedThrottler",
+    "NoThrottling"
+]

qubx/notifications/slack.py

@@ -1,17 +1,18 @@
 """
-Slack Strategy Lifecycle Notifier.
+Slack notifications for strategy lifecycle events.
 
-This module provides an implementation of IStrategyLifecycleNotifier that sends notifications to Slack.
+This module provides a Slack implementation of IStrategyLifecycleNotifier.
 """
 
 import datetime
 from concurrent.futures import ThreadPoolExecutor
-from typing import Dict, Optional
+from typing import Any
 
 import requests
 
 from qubx import logger
 from qubx.core.interfaces import IStrategyLifecycleNotifier
+from qubx.notifications.throttler import IMessageThrottler, NoThrottling
 
 
 class SlackLifecycleNotifier(IStrategyLifecycleNotifier):
@@ -30,6 +31,7 @@ class SlackLifecycleNotifier(IStrategyLifecycleNotifier):
         emoji_stop: str = ":checkered_flag:",
         emoji_error: str = ":rotating_light:",
         max_workers: int = 1,
+        throttler: IMessageThrottler | None = None,
     ):
         """
         Initialize the Slack Lifecycle Notifier.
@@ -40,18 +42,28 @@ class SlackLifecycleNotifier(IStrategyLifecycleNotifier):
             emoji_start: Emoji to use for start events
             emoji_stop: Emoji to use for stop events
             emoji_error: Emoji to use for error events
+            max_workers: Number of worker threads for posting messages
+            throttler: Optional message throttler to prevent flooding
         """
         self._webhook_url = webhook_url
         self._environment = environment
         self._emoji_start = emoji_start
         self._emoji_stop = emoji_stop
         self._emoji_error = emoji_error
+        self._throttler = throttler if throttler is not None else NoThrottling()
 
         self._executor = ThreadPoolExecutor(max_workers=max_workers, thread_name_prefix="slack_notifier")
 
         logger.info(f"[SlackLifecycleNotifier] Initialized for environment '{environment}'")
 
-    def _post_to_slack(self, message: str, emoji: str, color: str, metadata: Optional[Dict[str, any]] = None) -> None:
+    def _post_to_slack(
+        self,
+        message: str,
+        emoji: str,
+        color: str,
+        metadata: dict[str, Any] | None = None,
+        throttle_key: str | None = None,
+    ) -> None:
         """
         Submit a notification to be posted to Slack by the worker thread.
 
@@ -60,15 +72,26 @@ class SlackLifecycleNotifier(IStrategyLifecycleNotifier):
             emoji: Emoji to use in the message
             color: Color for the message attachment
             metadata: Optional dictionary with additional fields to include
+            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
+
             # Submit the task to the executor
-            self._executor.submit(self._post_to_slack_impl, message, emoji, color, metadata)
+            self._executor.submit(self._post_to_slack_impl, message, emoji, color, metadata, throttle_key)
         except Exception as e:
             logger.error(f"[SlackLifecycleNotifier] Failed to queue Slack message: {e}")
 
     def _post_to_slack_impl(
-        self, message: str, emoji: str, color: str, metadata: Optional[Dict[str, any]] = None
+        self,
+        message: str,
+        emoji: str,
+        color: str,
+        metadata: dict[str, Any] | None = None,
+        throttle_key: str | None = None,
     ) -> bool:
         """
         Implementation that actually posts to Slack (called from worker thread).
@@ -78,6 +101,7 @@ class SlackLifecycleNotifier(IStrategyLifecycleNotifier):
             emoji: Emoji to use in the message
             color: Color for the message attachment
             metadata: Optional dictionary with additional fields to include
+            throttle_key: Optional key used for throttling
 
         Returns:
             bool: True if the post was successful, False otherwise
@@ -107,13 +131,18 @@ 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:
             logger.error(f"[SlackLifecycleNotifier] Failed to post to Slack: {e}")
             return False
 
-    def notify_start(self, strategy_name: str, metadata: Optional[Dict[str, any]] = None) -> None:
+    def notify_start(self, strategy_name: str, metadata: dict[str, Any] | None = None) -> None:
         """
         Notify that a strategy has started.
 
@@ -128,7 +157,7 @@ class SlackLifecycleNotifier(IStrategyLifecycleNotifier):
         except Exception as e:
             logger.error(f"[SlackLifecycleNotifier] Failed to notify start: {e}")
 
-    def notify_stop(self, strategy_name: str, metadata: Optional[Dict[str, any]] = None) -> None:
+    def notify_stop(self, strategy_name: str, metadata: dict[str, Any] | None = None) -> None:
         """
         Notify that a strategy has stopped.
 
@@ -143,7 +172,7 @@ class SlackLifecycleNotifier(IStrategyLifecycleNotifier):
         except Exception as e:
             logger.error(f"[SlackLifecycleNotifier] Failed to notify stop: {e}")
 
-    def notify_error(self, strategy_name: str, error: Exception, metadata: Optional[Dict[str, any]] = None) -> None:
+    def notify_error(self, strategy_name: str, error: Exception, metadata: dict[str, Any] | None = None) -> None:
         """
         Notify that a strategy has encountered an error.
 
@@ -161,7 +190,11 @@ class SlackLifecycleNotifier(IStrategyLifecycleNotifier):
             metadata["Error Message"] = str(error)
 
             message = f"[{strategy_name}] ALERT: Strategy error in {self._environment}"
-            self._post_to_slack(message, self._emoji_error, "#FF0000", metadata)
+
+            # Create a throttle key for this strategy/error type combination
+            throttle_key = f"error:{strategy_name}:{type(error).__name__}"
+
+            self._post_to_slack(message, self._emoji_error, "#FF0000", metadata, throttle_key=throttle_key)
             logger.debug(f"[SlackLifecycleNotifier] Queued error notification for {strategy_name}")
         except Exception as e:
             logger.error(f"[SlackLifecycleNotifier] Failed to notify error: {e}")

qubx/notifications/throttler.py

@@ -0,0 +1,182 @@
+"""
+Message Throttling for Notifications.
+
+This module defines interfaces and implementations for throttling
+notification messages to prevent flooding notification channels.
+
+Usage Examples:
+    1. Basic TimeWindowThrottler with default settings (allows 1 message per key per 10 seconds):
+       ```python
+       from qubx.notifications.throttler import TimeWindowThrottler
+
+       throttler = TimeWindowThrottler()
+       if throttler.should_send("error:mystrategy:ValueError"):
+           # Send the message
+           send_message()
+           # Update the throttler
+           throttler.register_sent("error:mystrategy:ValueError")
+       ```
+
+    2. CountBasedThrottler (allows up to N messages per key within a time window):
+       ```python
+       from qubx.notifications.throttler import CountBasedThrottler
+
+       # Allow up to 5 messages per minute for each key
+       throttler = CountBasedThrottler(max_count=5, window_seconds=60.0)
+       ```
+
+    3. In a configuration file for SlackLifecycleNotifier:
+       ```yaml
+       notifiers:
+         - notifier: SlackLifecycleNotifier
+           parameters:
+             webhook_url: ${SLACK_WEBHOOK_URL}
+             environment: production
+             throttle:
+               type: TimeWindow
+               window_seconds: 30.0
+       ```
+"""
+
+import time
+from abc import ABC, abstractmethod
+
+
+class IMessageThrottler(ABC):
+    """Interface for message throttlers that can limit the frequency of notifications."""
+
+    @abstractmethod
+    def should_send(self, key: str) -> bool:
+        """
+        Determine if a message with the given key should be sent based on throttling rules.
+
+        Args:
+            key: A unique identifier for the type of message being sent
+                (e.g., "error:{strategy_name}")
+
+        Returns:
+            bool: True if the message should be sent, False if it should be throttled
+        """
+        pass
+
+    @abstractmethod
+    def register_sent(self, key: str) -> None:
+        """
+        Register that a message with the given key was sent.
+        This updates the internal state of the throttler.
+
+        Args:
+            key: A unique identifier for the type of message that was sent
+        """
+        pass
+
+
+class TimeWindowThrottler(IMessageThrottler):
+    """
+    Throttles messages based on a time window.
+
+    Only allows one message per key within a specified time window.
+    """
+
+    def __init__(self, window_seconds: float = 10.0):
+        """
+        Initialize the time window throttler.
+
+        Args:
+            window_seconds: Minimum time between messages with the same key, in seconds
+        """
+        self._window_seconds = window_seconds
+        self._last_sent_times: dict[str, float] = {}
+
+    def should_send(self, key: str) -> bool:
+        """
+        Check if a message with the given key should be sent based on the time window.
+
+        Args:
+            key: Message key to check
+
+        Returns:
+            bool: True if enough time has passed since the last message with this key
+        """
+        current_time = time.time()
+        last_sent = self._last_sent_times.get(key, 0)
+        return (current_time - last_sent) >= self._window_seconds
+
+    def register_sent(self, key: str) -> None:
+        """
+        Register that a message with the given key was sent.
+
+        Args:
+            key: Key of the message that was sent
+        """
+        self._last_sent_times[key] = time.time()
+
+
+class CountBasedThrottler(IMessageThrottler):
+    """
+    Throttles messages based on a count within a time window.
+
+    Allows a specified number of messages per key within a time window.
+    """
+
+    def __init__(self, max_count: int = 3, window_seconds: float = 60.0):
+        """
+        Initialize the count-based throttler.
+
+        Args:
+            max_count: Maximum number of messages allowed in the time window
+            window_seconds: Time window in seconds
+        """
+        self._max_count = max_count
+        self._window_seconds = window_seconds
+        self._message_history: dict[str, list[float]] = {}
+
+    def should_send(self, key: str) -> bool:
+        """
+        Check if a message with the given key should be sent based on the count limit.
+
+        Args:
+            key: Message key to check
+
+        Returns:
+            bool: True if the message count is below the limit
+        """
+        current_time = time.time()
+
+        # Initialize history for this key if it doesn't exist
+        if key not in self._message_history:
+            self._message_history[key] = []
+
+        # Remove timestamps older than the window
+        self._message_history[key] = [
+            ts for ts in self._message_history[key] if (current_time - ts) < self._window_seconds
+        ]
+
+        # Check if we're under the message count limit
+        return len(self._message_history[key]) < self._max_count
+
+    def register_sent(self, key: str) -> None:
+        """
+        Register that a message with the given key was sent.
+
+        Args:
+            key: Key of the message that was sent
+        """
+        current_time = time.time()
+
+        if key not in self._message_history:
+            self._message_history[key] = []
+
+        self._message_history[key].append(current_time)
+
+
+class NoThrottling(IMessageThrottler):
+    """A throttler implementation that doesn't actually throttle - allows all messages."""
+
+    def should_send(self, key: str) -> bool:
+        """Always returns True, allowing all messages to be sent."""
+        return True
+
+    def register_sent(self, key: str) -> None:
+        """No-op implementation."""
+        pass

qubx/pandaz/utils.py

@@ -23,7 +23,10 @@ def check_frame_columns(x, *args):
 
 
 def rolling_forward_test_split(
-    x: pd.Series | pd.DataFrame, training_period: int, test_period: int, units: str | None = None
+    x: pd.Series | pd.DataFrame,
+    training_period: int,
+    test_period: int,
+    units: str | None = None,
 ):
     """
     Split data into training and testing **rolling** periods.
@@ -51,7 +54,7 @@ def rolling_forward_test_split(
     :return:
     """
     # unit formats from pd.TimeDelta and formats for pd.resample
-    units_format = {"H": "H", "D": "D", "W": "W", "M": "MS", "Q": "QS", "Y": "AS"}
+    units_format = {"H": "h", "D": "d", "W": "W", "M": "MS", "Q": "QS", "Y": "AS", "MIN": "min"}
 
     if units:
         if units.upper() not in units_format:

qubx/utils/runner/configs.py

@@ -121,7 +121,8 @@ def load_strategy_config_from_yaml(path: Path | str, key: str | None = None) ->
 class StrategySimulationConfig(BaseModel):
     strategy: str | list[str]
     parameters: dict = Field(default_factory=dict)
-    data: dict = Field(default_factory=dict)
+    data: list[TypedReaderConfig] = Field(default_factory=list)
+    aux: ReaderConfig | None = None
     simulation: dict = Field(default_factory=dict)
     description: str | list[str] | None = None
     variate: dict = Field(default_factory=dict)

qubx/utils/runner/factory.py

@@ -12,7 +12,7 @@ from qubx.data.composite import CompositeReader
 from qubx.data.readers import DataReader
 from qubx.emitters.composite import CompositeMetricEmitter
 from qubx.utils.misc import class_import
-from qubx.utils.runner.configs import EmissionConfig, ExporterConfig, NotifierConfig, ReaderConfig, WarmupConfig
+from qubx.utils.runner.configs import EmissionConfig, ExporterConfig, NotifierConfig, ReaderConfig, TypedReaderConfig
 
 
 def resolve_env_vars(value: str | Any) -> str | Any:
@@ -118,27 +118,27 @@ def create_metric_emitters(emission_config: EmissionConfig, strategy_name: str)
         return CompositeMetricEmitter(emitters, stats_interval=stats_interval)
 
 
-def create_data_type_readers(warmup: WarmupConfig | None) -> dict[str, DataReader]:
+def create_data_type_readers(readers_configs: list[TypedReaderConfig] | None) -> dict[str, DataReader]:
     """
-    Create a dictionary mapping data types to readers based on the warmup configuration.
+    Create a dictionary mapping data types to readers based on the readers list.
 
     This function ensures that identical reader configurations are only instantiated once,
     and multiple data types can share the same reader instance if they have identical configurations.
 
     Args:
-        warmup: The warmup configuration containing reader definitions.
+        readers_configs: The readers list containing reader definitions.
 
     Returns:
         A dictionary mapping data types to reader instances.
     """
-    if warmup is None:
+    if readers_configs is None:
         return {}
 
     # First, create unique readers to avoid duplicate instantiation
     unique_readers = {}  # Maps reader config hash to reader instance
     data_type_to_reader = {}  # Maps data type to reader instance
 
-    for typed_reader_config in warmup.readers:
+    for typed_reader_config in readers_configs:
         data_types = typed_reader_config.data_type
         if isinstance(data_types, str):
             data_types = [data_types]
@@ -259,7 +259,7 @@ def create_lifecycle_notifiers(
     Create lifecycle notifiers from the configuration.
 
     Args:
-        config: Strategy configuration
+        notifiers: List of notifier configurations
         strategy_name: Name of the strategy
 
     Returns:
@@ -283,6 +283,57 @@ def create_lifecycle_notifiers(
             for key, value in notifier_config.parameters.items():
                 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:
+                # Import here to avoid circular imports
+                from qubx.notifications.throttler import TimeWindowThrottler
+
+                # Create default throttler with 10s window
+                default_window = 10.0
+                params["throttler"] = TimeWindowThrottler(window_seconds=default_window)
+                logger.info(
+                    f"Using default TimeWindowThrottler with window={default_window}s for {notifier_class_name}"
+                )
+            elif "throttle" in params:
+                throttle_config = params.pop("throttle")
+
+                if isinstance(throttle_config, dict):
+                    throttler_type = throttle_config.get("type", "TimeWindow")
+                    window_seconds = float(throttle_config.get("window_seconds", 10.0))
+                    max_count = int(throttle_config.get("max_count", 3))
+
+                    if throttler_type.lower() == "timewindow":
+                        from qubx.notifications.throttler import TimeWindowThrottler
+
+                        throttler = TimeWindowThrottler(window_seconds=window_seconds)
+                        logger.info(f"Created TimeWindowThrottler with window_seconds={window_seconds}")
+                    elif throttler_type.lower() == "countbased":
+                        from qubx.notifications.throttler import CountBasedThrottler
+
+                        throttler = CountBasedThrottler(max_count=max_count, window_seconds=window_seconds)
+                        logger.info(
+                            f"Created CountBasedThrottler with max_count={max_count}, window_seconds={window_seconds}"
+                        )
+                    elif throttler_type.lower() == "none":
+                        from qubx.notifications.throttler import NoThrottling
+
+                        throttler = NoThrottling()
+                        logger.info("Created NoThrottling throttler")
+                    else:
+                        logger.warning(f"Unknown throttler type '{throttler_type}', defaulting to TimeWindowThrottler")
+                        from qubx.notifications.throttler import TimeWindowThrottler
+
+                        throttler = TimeWindowThrottler(window_seconds=window_seconds)
+
+                    params["throttler"] = throttler
+                elif isinstance(throttle_config, (int, float)):
+                    # Simple case: just a window_seconds value
+                    from qubx.notifications.throttler import TimeWindowThrottler
+
+                    throttler = TimeWindowThrottler(window_seconds=float(throttle_config))
+                    logger.info(f"Created TimeWindowThrottler with window_seconds={throttle_config}")
+                    params["throttler"] = throttler
+
             # Create the notifier instance
             notifier = notifier_class(**params)
             _notifiers.append(notifier)

qubx/utils/runner/runner.py

@@ -49,7 +49,7 @@ from qubx.loggers import create_logs_writer
 from qubx.restarts.state_resolvers import StateResolver
 from qubx.restarts.time_finders import TimeFinder
 from qubx.restorers import create_state_restorer
-from qubx.utils.misc import class_import, makedirs, red
+from qubx.utils.misc import class_import, green, makedirs, red
 from qubx.utils.runner.configs import (
     ExchangeConfig,
     LoggingConfig,
@@ -533,9 +533,7 @@ def _create_broker(
                 secret=creds.secret,
                 enable_mm=_enable_mm,
             )
-            return get_ccxt_broker(
-                exchange_name, exchange, channel, time_provider, account, data_provider, **params
-            )
+            return get_ccxt_broker(exchange_name, exchange, channel, time_provider, account, data_provider, **params)
         case "paper":
             assert isinstance(account, SimulatedAccountProcessor)
             return SimulatedBroker(channel=channel, account=account, simulated_exchange=account._exchange)
@@ -597,7 +595,7 @@ def _run_warmup(
     logger.info(f"<yellow>Warmup start time: {warmup_start_time}</yellow>")
 
     # - construct warmup readers
-    data_type_to_reader = create_data_type_readers(warmup)
+    data_type_to_reader = create_data_type_readers(warmup.readers) if warmup else {}
 
     if not data_type_to_reader:
         logger.warning("<yellow>No readers were created for warmup</yellow>")
@@ -745,10 +743,8 @@ def simulate_strategy(
         experiments = {simulation_name: strategy}
         _n_jobs = 1
 
-    data_i = {}
-
-    for k, v in cfg.data.items():
-        data_i[k] = eval(v)
+    # - resolve data readers
+    data_i = create_data_type_readers(cfg.data) if cfg.data else {}
 
     sim_params = cfg.simulation
     for mp in ["instruments", "capital", "commissions", "start", "stop"]:
@@ -764,18 +760,13 @@ def simulate_strategy(
         logger.info(f"Stop date set to {stop}")
 
     # - check for aux_data parameter
-    if "aux_data" in sim_params:
-        aux_data = sim_params.pop("aux_data")
-        if aux_data is not None:
-            try:
-                sim_params["aux_data"] = eval(aux_data)
-            except Exception as e:
-                raise ValueError(f"Invalid aux_data parameter: {aux_data}") from e
+    if cfg.aux is not None:
+        sim_params["aux_data"] = construct_reader(cfg.aux)
 
     # - 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)
+    test_res = simulate(experiments, data=data_i, **sim_params)  # type: ignore
 
     _where_to_save = save_path if save_path is not None else Path("results/")
     s_path = Path(makedirs(str(_where_to_save))) / simulation_name
@@ -791,13 +782,13 @@ def simulate_strategy(
     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> ...")
+        print(f" > Saving variations results to {green(s_path)} ...")
         for k, t in enumerate(test_res):
             # - set variation name
             t.variation_name = f"{simulation_name}.{_v_id}"
             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> ...")
+        print(f" > Saving simulation results to {green(s_path)} ...")
         test_res[0].to_file(str(s_path), description=_descr, attachments=[str(config_file)])
 
     return test_res

{qubx-0.6.38.dist-info → qubx-0.6.41.dist-info}/METADATA

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

{qubx-0.6.38.dist-info → qubx-0.6.41.dist-info}/RECORD

@@ -1,5 +1,5 @@
 qubx/__init__.py,sha256=GBvbyDpm2yCMJVmGW66Jo0giLOUsKKldDGcVA_r9Ohc,8294
-qubx/_nb_magic.py,sha256=kcYn8qNb8O223ZRPpq30_n5e__lD5GSVcd0U_jhfnbM,3019
+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
@@ -9,12 +9,12 @@ qubx/backtester/ome.py,sha256=Uf3wqyVjUEpm1jrDQ4PE77E3R3B7wJJy1vaOOmvQqWg,15610
 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=ATGcJXnKdD47kUwgbc5tvPVL0tq4_-6jpgsTTAMxW3c,8124
+qubx/backtester/simulated_exchange.py,sha256=Xg0yv21gq4q9CeCeZoupcenNEBORrxpb93ONZEGL2xk,8076
 qubx/backtester/simulator.py,sha256=cSbW42X-YlAutZlOQ3Y4mAJWXr_1WomYprtWZVMe3Uk,9225
 qubx/backtester/utils.py,sha256=nHrgKcIkyp5gz8wrPwMp1fRItUtQfvOPjxZhcaCwN-o,32729
 qubx/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubx/cli/commands.py,sha256=EwGqbNvY5VRCEO9T1w0GgqtcEvPFYMW96KzC-FPUvDM,7259
-qubx/cli/deploy.py,sha256=WfrEJ4n_e_xB6e1JstP2Rb4EGIxCftqG_flT03fjPXE,7595
+qubx/cli/deploy.py,sha256=pQ9FPOsywDyy8jOjLfrgYTTkKQ-MCixCzbgsG68Q3_0,8319
 qubx/cli/misc.py,sha256=tP28QxLEzuP8R2xnt8g3JTs9Z7aYy4iVWY4g3VzKTsQ,14777
 qubx/cli/release.py,sha256=JYdNt_ZM9jarmYiRDtKqbRqqllzm2Qwi6VggokB2j8A,28167
 qubx/connectors/ccxt/__init__.py,sha256=HEQ7lM9HS8sED_zfsAHrhFT7F9E7NFGAecwZwNr-TDE,65
@@ -40,23 +40,23 @@ qubx/core/context.py,sha256=ZetAOnQ9pfUiMAFln02zJr4FePTjKaY5OSIVwaMPhnE,22822
 qubx/core/deque.py,sha256=3PsmJ5LF76JpsK4Wp5LLogyE15rKn6EDCkNOOWT6EOk,6203
 qubx/core/errors.py,sha256=LENtlgmVzxxUFNCsuy4PwyHYhkZkxuZQ2BPif8jaGmw,1411
 qubx/core/exceptions.py,sha256=11wQC3nnNLsl80zBqbE6xiKCqm31kctqo6W_gdnZkg8,581
-qubx/core/helpers.py,sha256=qzRsttt4sMYMarDWMzWvc3b2W-Qp9qAQwFiQBljAsA0,19722
+qubx/core/helpers.py,sha256=m7JrZaBckXHb4zjhKpdCbxFe3kfda-SCNLfagyq7Ve4,19158
 qubx/core/initializer.py,sha256=PUiD_cIjvGpuPjYyRpUjpwm3xNQ2Kipa8bAhbtxCQRo,3935
 qubx/core/interfaces.py,sha256=CzIl8tB6ImQkDcZEmhpstwHPOCY8NhZxXmBHLQUAieI,58253
 qubx/core/loggers.py,sha256=0g33jfipGFShSMrXBoYVzL0GfTzI36mwBJqHNUHmhdo,13342
 qubx/core/lookups.py,sha256=n5ZjjEhhRvmidCB-Cubr1b0Opm6lf_QVZNEWa_BOQG0,19376
-qubx/core/metrics.py,sha256=Gq3Ultwn5meICfyauBUJrBS4nffSxFVH3OF6N1Y0xgo,58664
+qubx/core/metrics.py,sha256=IUTVDfO7HW68GGoLsj6kkLz8ueg-bnXRiWflIts8K_w,60264
 qubx/core/mixins/__init__.py,sha256=AMCLvfNuIb1kkQl3bhCj9jIOEl2eKcVPJeyLgrkB-rk,329
 qubx/core/mixins/market.py,sha256=lBappEimPhIuI0vmUvwVlIztkYjlEjJBpP-AdpfudII,3948
-qubx/core/mixins/processing.py,sha256=dqehukrfqcLy5BeILKnkpHCvva4SbLKj1ZbQdnByu1k,24552
+qubx/core/mixins/processing.py,sha256=cmjD0PcQv3gFP6oILfNgdNgw7Tez0fUZu_nFn6680VI,24979
 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=L3s2Jw46_J1iDh4622Gk_LvCjol4W7mflBwEHrLfZEw,9899
-qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=oCjBv31hRr3bJ47EucFuzDzwStG05dUWTNyAXBg2HwQ,978280
+qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=kaqGuSydE041VcwqUyHpIybK27yE1g-INOtDP1zfI8Q,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=jpJmqz2ebCWD6_Wb8-IkGvGLhhgT2Gk0f2EmL8bkUC8,86568
+qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=LWgrhKGrBQ7wFwPPHwZgjqPZxcRLzq81z0x3B1iiBE0,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
@@ -65,7 +65,7 @@ qubx/data/helpers.py,sha256=VcXBl1kfWzAOqrjadKrP9WemGjJIB0q3xascbesErh4,16268
 qubx/data/hft.py,sha256=be7AwzTOjqqCENn0ClrZoHDyKv3SFG66IyTp8QadHlM,33687
 qubx/data/readers.py,sha256=H68n38VLMjjk8R5FW7URGLcJCh0MREKFGdMGgWCWzhU,62503
 qubx/data/registry.py,sha256=45mjy5maBSO6cf-0zfIRRDs8b0VDW7wHSPn43aRjv-o,3883
-qubx/data/tardis.py,sha256=VMw13tIIlrGZwermKvdFRSNtLUiJDGOKW4l6WuAMQSA,33747
+qubx/data/tardis.py,sha256=O-zglpusmO6vCY3arSOgH6KUbkfPajSAIQfMKlVmh_E,33878
 qubx/emitters/__init__.py,sha256=tpJ9OoW-gycTBXGJ0647tT8-dVBmq23T2wMX_kmk3nM,565
 qubx/emitters/base.py,sha256=z0CiEnIGkizd-4Btvq9Auxg3BpnkKN6M8-ksAH2enQc,7745
 qubx/emitters/composite.py,sha256=8DsPIUtaJ95Oww9QTVVB6LR7Wcb6TJ-c1jIHMGuttz4,2784
@@ -96,12 +96,13 @@ qubx/loggers/inmemory.py,sha256=49Y-jsRxDzBLWQdQMIKjVTvnx_79EbjFpHwj3v8Mgno,2642
 qubx/loggers/mongo.py,sha256=dOEpCcIxT6O9MgpK2srpzxyuto6QaQgTxMK0WcEIR70,2703
 qubx/math/__init__.py,sha256=ltHSQj40sCBm3owcvtoZp34h6ws7pZCFcSZgUkTsUCY,114
 qubx/math/stats.py,sha256=uXm4NpBRxuHFTjXERv8rjM0MAJof8zr1Cklyra4CcBA,4056
-qubx/notifications/__init__.py,sha256=2xsk3kPykiNZDZv0y4YMDbgnFvKy14SkNeg7StHk4bI,340
+qubx/notifications/__init__.py,sha256=cb3DGxuiA8UwSTlTeF5pQKy4-vBef3gMeKtfcxEjdN4,547
 qubx/notifications/composite.py,sha256=fa-rvHEn6k-Fma5N7cT-7Sk7hzVyB0KDs2ktDyoyLxM,2689
-qubx/notifications/slack.py,sha256=Odwx_qBrDoZPARp9ENmMI957FM1v5BvpUIWOuatrM0o,6711
+qubx/notifications/slack.py,sha256=FZ0zfTA-zRHOsOsIVBtM7mkt4m-adiuiV5yrwliS9RM,7976
+qubx/notifications/throttler.py,sha256=8jnymPQbrgtN1rD7REQa2sA9teSWTqkk_uT9oaknOyc,5618
 qubx/pandaz/__init__.py,sha256=6BYz6gSgxjNa7WP1XqWflYG7WIq1ppSD9h1XGR5M5YQ,682
 qubx/pandaz/ta.py,sha256=SjK3jORf6Q3XYBwTixXnjK5elbzdvT14WR2OJdQXo20,91666
-qubx/pandaz/utils.py,sha256=zAHUIAApSRrlQa5AjpIbiQ9ftSGIBOu_ppDg0c3gXaE,23380
+qubx/pandaz/utils.py,sha256=f7airZjUKHkhKICL0HF_R9Vvcswdgef7Yr35Xb_Ppzs,23407
 qubx/resources/_build.py,sha256=XE7XNuDqfXPc2OriLobKXmPMvwa7Z8AKAD-18fnf0e4,8802
 qubx/resources/instruments/symbols-binance.cm.json,sha256=rNI3phNeeRY95_IE7_0Um9d5U4jUtEijZQ_PaYg5cdw,25127
 qubx/resources/instruments/symbols-binance.json,sha256=Qx_XckgsWNhmmV8_t5DpG0AeGkuTyt1uiif2EeeBDIg,939678
@@ -122,7 +123,7 @@ qubx/restorers/signal.py,sha256=9TAaJOEKPjZXuciFFVn6Z8a-Z8CfVSjRGFRcwEgbPLY,1074
 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=EAm2KZhw7wkpqvoEQRH9a3Z2enYqYQkk5EdVVOPuB6s,654440
+qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=CCvVqxcz64fK-Am57qTJzknn3CNYY-8PFEHlRgj7RTI,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
@@ -154,13 +155,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=4lonQgksh4wDygsN67lIidVRIUksskWuhL25A2IZwho,3694
-qubx/utils/runner/factory.py,sha256=vQ2dBTbrQE9YH__-TvuFzGF-E1li-vt_qQum9GHa11g,11666
-qubx/utils/runner/runner.py,sha256=dyrwFiVmU3nkgGiDRIg6cxhikf3KJ4ylEdojUdf9WaQ,29070
+qubx/utils/runner/configs.py,sha256=nxIelzfHtv7GagkEHBJ6mRm_30jmBa6pSPujL-k0uqo,3749
+qubx/utils/runner/factory.py,sha256=Mh_soHKci7Xj5uYI3vhxzXkrPUm2Z-Cq3PGC6w3KCUY,14620
+qubx/utils/runner/runner.py,sha256=egv4OtPwEIwG0-Ia3ai9E9MYQIaslZLyoT4tL1FxQcY,28891
 qubx/utils/time.py,sha256=J0ZFGjzFL5T6GA8RPAel8hKG0sg2LZXeQ5YfDCfcMHA,10055
 qubx/utils/version.py,sha256=e52fIHyxzCiIuH7svCF6pkHuDlqL64rklqz-2XjWons,5309
-qubx-0.6.38.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
-qubx-0.6.38.dist-info/METADATA,sha256=_71dUs78KDAbSy2GWSHBg_oTYYZnugqV8e8oACi9t-4,4492
-qubx-0.6.38.dist-info/WHEEL,sha256=XjdW4AGUgFDhpG9b3b2KPhtR_JLZvHyfemLgJJwcqOI,110
-qubx-0.6.38.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
-qubx-0.6.38.dist-info/RECORD,,
+qubx-0.6.41.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
+qubx-0.6.41.dist-info/METADATA,sha256=TdDDd1n1SALzg1jwDaAG153aD7-MqDAJh40T--FQ-4c,4492
+qubx-0.6.41.dist-info/WHEEL,sha256=UckHTmFUCaLKpi4yFY8Dewu0c6XkY-KvEAGzGOnaWo8,110
+qubx-0.6.41.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
+qubx-0.6.41.dist-info/RECORD,,

{qubx-0.6.38.dist-info → qubx-0.6.41.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.2
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: false
 Tag: cp312-cp312-manylinux_2_39_x86_64