Qubx 0.6.38__tar.gz → 0.6.41__tar.gz

{qubx-0.6.38 → qubx-0.6.41}/PKG-INFO

@@ -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 → qubx-0.6.41}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "Qubx"
-version = "0.6.38"
+version = "0.6.41"
 description = "Qubx - Quantitative Trading Framework"
 authors = [ "Dmitry Marienko <dmitry.marienko@xlydian.com>", "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",]
 readme = "README.md"

{qubx-0.6.38 → qubx-0.6.41}/src/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-0.6.38 → qubx-0.6.41}/src/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-0.6.38 → qubx-0.6.41}/src/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-0.6.38 → qubx-0.6.41}/src/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-0.6.38 → qubx-0.6.41}/src/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-0.6.38 → qubx-0.6.41}/src/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-0.6.38 → qubx-0.6.41}/src/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-0.6.41/src/qubx/notifications/__init__.py

@@ -0,0 +1,19 @@
+"""
+Notifications package for strategy lifecycle events.
+
+This package provides implementations of the IStrategyLifecycleNotifier interface
+for various notification channels.
+"""
+
+from .composite import CompositeLifecycleNotifier
+from .slack import SlackLifecycleNotifier
+from .throttler import CountBasedThrottler, IMessageThrottler, NoThrottling, TimeWindowThrottler
+
+__all__ = [
+    "CompositeLifecycleNotifier", 
+    "SlackLifecycleNotifier",
+    "IMessageThrottler",
+    "TimeWindowThrottler",
+    "CountBasedThrottler",
+    "NoThrottling"
+]

{qubx-0.6.38 → qubx-0.6.41}/src/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-0.6.41/src/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