Qubx 0.6.40__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.42__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/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
@@ -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/exporters/formatters/incremental.py

@@ -13,7 +13,12 @@ class IncrementalFormatter(DefaultFormatter):
     based on leverage changes.
     """
 
-    def __init__(self, alert_name: str, exchange_mapping: Optional[Dict[str, str]] = None):
+    def __init__(
+            self, 
+            alert_name: str, 
+            exchange_mapping: Optional[Dict[str, str]] = None,
+            account: Optional[IAccountViewer] = None
+    ):
         """
         Initialize the IncrementalFormatter.
 
@@ -21,12 +26,16 @@ class IncrementalFormatter(DefaultFormatter):
             alert_name: The name of the alert to include in the messages
             exchange_mapping: Optional mapping of exchange names to use in messages.
                              If an exchange is not in the mapping, the instrument's exchange is used.
+            account: The account viewer to get account information like total capital, leverage, etc.
         """
         super().__init__()
         self.alert_name = alert_name
         self.exchange_mapping = exchange_mapping or {}
         self.instrument_leverages: Dict[Instrument, float] = {}
 
+        if account:
+            self.instrument_leverages = dict(account.get_leverages())
+
     def format_position_change(
         self, time: dt_64, instrument: Instrument, price: float, account: IAccountViewer
     ) -> dict[str, Any]:

qubx/exporters/redis_streams.py

@@ -36,6 +36,7 @@ class RedisStreamsExporter(ITradeDataExport):
         max_stream_length: int = 1000,
         formatter: Optional[IExportFormatter] = None,
         max_workers: int = 2,
+        account: Optional[IAccountViewer] = None,
     ):
         """
         Initialize the Redis Streams Exporter.
@@ -52,6 +53,7 @@ class RedisStreamsExporter(ITradeDataExport):
             max_stream_length: Maximum length of each stream
             formatter: Formatter to use for formatting data (default: DefaultFormatter)
             max_workers: Maximum number of worker threads for Redis operations
+            account: Optional account viewer to get account information like total capital, leverage, etc.
         """
         self._redis = redis.from_url(redis_url)
         self._strategy_name = strategy_name
@@ -71,6 +73,9 @@ class RedisStreamsExporter(ITradeDataExport):
 
         self._executor = ThreadPoolExecutor(max_workers=max_workers, thread_name_prefix="redis_exporter")
 
+        if account:
+            self._instrument_to_previous_leverage = dict(account.get_leverages())
+
         logger.info(
             f"[RedisStreamsExporter] Initialized for strategy '{strategy_name}' with "
             f"signals: {export_signals}, targets: {export_targets}, position_changes: {export_position_changes}"
@@ -201,6 +206,7 @@ class RedisStreamsExporter(ITradeDataExport):
 
         previous_leverage = self._instrument_to_previous_leverage.get(instrument, 0.0)
         new_leverage = account.get_leverage(instrument)
+        self._instrument_to_previous_leverage[instrument] = new_leverage
 
         try:
             # Format the leverage change using the formatter

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

@@ -4,10 +4,10 @@ Factory functions for creating various components used in strategy running and s
 
 import inspect
 import os
-from typing import Any
+from typing import Any, Optional
 
 from qubx import logger
-from qubx.core.interfaces import IMetricEmitter, IStrategyLifecycleNotifier, ITradeDataExport
+from qubx.core.interfaces import IAccountViewer, IMetricEmitter, IStrategyLifecycleNotifier, ITradeDataExport
 from qubx.data.composite import CompositeReader
 from qubx.data.readers import DataReader
 from qubx.emitters.composite import CompositeMetricEmitter
@@ -180,7 +180,11 @@ def create_data_type_readers(readers_configs: list[TypedReaderConfig] | None) ->
     return data_type_to_reader
 
 
-def create_exporters(exporters: list[ExporterConfig] | None, strategy_name: str) -> ITradeDataExport | None:
+def create_exporters(
+        exporters: list[ExporterConfig] | None, 
+        strategy_name: str,
+        account: Optional[IAccountViewer] = None,
+) -> ITradeDataExport | None:
     """
     Create exporters from the configuration.
 
@@ -218,6 +222,9 @@ def create_exporters(exporters: list[ExporterConfig] | None, strategy_name: str)
                     for fmt_key, fmt_value in formatter_args.items():
                         formatter_args[fmt_key] = resolve_env_vars(fmt_value)
 
+                    if account and "account" not in formatter_args:
+                        formatter_args["account"] = account
+
                     if formatter_class_name:
                         if "." not in formatter_class_name:
                             formatter_class_name = f"qubx.exporters.formatters.{formatter_class_name}"
@@ -229,6 +236,8 @@ def create_exporters(exporters: list[ExporterConfig] | None, strategy_name: str)
             # Add strategy_name if the exporter requires it and it's not already provided
             if "strategy_name" in inspect.signature(exporter_class).parameters and "strategy_name" not in params:
                 params["strategy_name"] = strategy_name
+            if account and "account" not in params:
+                params["account"] = account
 
             # Create the exporter instance
             exporter = exporter_class(**params)
@@ -259,7 +268,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 +292,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

@@ -261,9 +261,6 @@ def create_strategy_context(
 
     _aux_reader = construct_reader(config.aux) if config.aux else None
 
-    # Create exporters if configured
-    _exporter = create_exporters(config.exporters, stg_name)
-
     # Create metric emitters
     _metric_emitter = create_metric_emitters(config.emission, stg_name) if config.emission else None
 
@@ -335,6 +332,9 @@ def create_strategy_context(
     )
     _initializer = BasicStrategyInitializer(simulation=_exchange_to_data_provider[exchanges[0]].is_simulation)
 
+    # Create exporters if configured
+    _exporter = create_exporters(config.exporters, stg_name, _account)
+
     logger.info(f"- Strategy: <blue>{stg_name}</blue>\n- Mode: {_run_mode}\n- Parameters: {config.parameters}")
     ctx = StrategyContext(
         strategy=_strategy_class,  # type: ignore

{qubx-0.6.40.dist-info → qubx-0.6.42.dist-info}/METADATA

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

{qubx-0.6.40.dist-info → qubx-0.6.42.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,7 +9,7 @@ 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
@@ -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=3zB4XISayK_rF4RkOB3QMMshg8IFq_Z0Xqwcf_Y5bhg,58713
+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=vh0iqqRGDBZy1F9LjMMjhF3txG_zcB7J4pu0XPYmDdc,978280
+qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=8DijkxPrz0lEvZCp81RfOj5oaxVt_0YTq0ihU5UtIVs,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=9Wj1t1JoF9F3ic-tCyzlC2F8m1nF_HOIHIqHdLjywwo,86568
+qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=pP6PczrIK0qymrZDt2sywmhnkhCZqyPpzxT_4680uFU,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
@@ -76,9 +76,9 @@ qubx/exporters/__init__.py,sha256=7HeYHCZfKAaBVAByx9wE8DyGv6C55oeED9uUphcyjuc,36
 qubx/exporters/composite.py,sha256=c45XcMC0dsIDwOyOxxCuiyYQjUNhqPjptAulbaSqttU,2973
 qubx/exporters/formatters/__init__.py,sha256=La9rMsl3wyplza0xVyAFrUwhFyrGDIMJWmOB_boJyIg,488
 qubx/exporters/formatters/base.py,sha256=j381c-JgjUnUHJF7k1J1MPeHB0sFDC9xNcFt2jZNhNY,5671
-qubx/exporters/formatters/incremental.py,sha256=tzjD4eWzane_MqCI_s9EFMy4ZurLwWqpL0Uaitv-wS4,4918
+qubx/exporters/formatters/incremental.py,sha256=06r7LId5LoZD5VY7V0VQE4q3h2t4VxlP2SgF8j3xua0,5209
 qubx/exporters/formatters/slack.py,sha256=MPjbEFh7PQufPdkg_Fwiu2tVw5zYJa977tCemoI790Y,7017
-qubx/exporters/redis_streams.py,sha256=8Cd39kAXUYSOS6-dQMSm1PpeQ4urOGVq0oe3dAXwUEI,8924
+qubx/exporters/redis_streams.py,sha256=ywbZrrqJDbMmV4QIW_XHBFh8NZu8gbOb47P3WH6UXIk,9257
 qubx/exporters/slack.py,sha256=wnVZRwWOKq9lMQyW0MWh_6gkW1id1TUanfOKy-_clwI,7723
 qubx/features/__init__.py,sha256=ZFCX7K5bDAH7yTsG-mf8zibW8UW8GCneEagL1_p8kDQ,385
 qubx/features/core.py,sha256=eXa1qIu-LXo40td1X4EUBFQ5jJcSTuaQIi-562bPCoM,10587
@@ -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=dr8KjRec6PNcjTCGOzlnt-G6e5xCMw0jEoNtP4RbYI4,654440
+qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=NK4SU3DKjt9hjTM0N2_8zuGDYH8lZiLEMtOL3c4saog,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
@@ -155,12 +156,12 @@ qubx/utils/runner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 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=nxIelzfHtv7GagkEHBJ6mRm_30jmBa6pSPujL-k0uqo,3749
-qubx/utils/runner/factory.py,sha256=EwtM1mE-w2IwWcWoazNITsPPl9Q_5K9IDtxfQc4BaZA,11694
-qubx/utils/runner/runner.py,sha256=egv4OtPwEIwG0-Ia3ai9E9MYQIaslZLyoT4tL1FxQcY,28891
+qubx/utils/runner/factory.py,sha256=8IxKvsEL0opx5OlO4XEQgAlmu05sgxXxkY4G2MQdLbg,14941
+qubx/utils/runner/runner.py,sha256=DhICMOfgE0i7VEC7pNMSEzIyZbb-TbOa6FbR1obZpyc,28901
 qubx/utils/time.py,sha256=J0ZFGjzFL5T6GA8RPAel8hKG0sg2LZXeQ5YfDCfcMHA,10055
 qubx/utils/version.py,sha256=e52fIHyxzCiIuH7svCF6pkHuDlqL64rklqz-2XjWons,5309
-qubx-0.6.40.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
-qubx-0.6.40.dist-info/METADATA,sha256=V2Xo_isQ1pWzbVKAKgUI8mTZDok7ZCy4UxuF3QuS_nI,4492
-qubx-0.6.40.dist-info/WHEEL,sha256=XjdW4AGUgFDhpG9b3b2KPhtR_JLZvHyfemLgJJwcqOI,110
-qubx-0.6.40.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
-qubx-0.6.40.dist-info/RECORD,,
+qubx-0.6.42.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
+qubx-0.6.42.dist-info/METADATA,sha256=IimoSRSYNj-wJp_LKP7T4Gr0OVu_9Wuxo7Pm2unbjp4,4492
+qubx-0.6.42.dist-info/WHEEL,sha256=UckHTmFUCaLKpi4yFY8Dewu0c6XkY-KvEAGzGOnaWo8,110
+qubx-0.6.42.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
+qubx-0.6.42.dist-info/RECORD,,

{qubx-0.6.40.dist-info → qubx-0.6.42.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