onesecondtrader 0.8.0__tar.gz → 0.10.0__tar.gz

{onesecondtrader-0.8.0 → onesecondtrader-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: onesecondtrader
-Version: 0.8.0
+Version: 0.10.0
 Summary: The Trading Infrastructure Toolkit for Python. Research, simulate, and deploy algorithmic trading strategies — all in one place.
 Author: Nils P. Kujath
 Author-email: 63961429+NilsKujath@users.noreply.github.com

{onesecondtrader-0.8.0 → onesecondtrader-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onesecondtrader"
-version = "0.8.0"
+version = "0.10.0"
 description = "The Trading Infrastructure Toolkit for Python. Research, simulate, and deploy algorithmic trading strategies — all in one place."
 authors = [
     {name = "Nils P. Kujath",email = "63961429+NilsKujath@users.noreply.github.com"}

{onesecondtrader-0.8.0 → onesecondtrader-0.10.0}/src/onesecondtrader/core/models.py

@@ -131,3 +131,29 @@ class OrderRejectionReason(enum.Enum):
 
     UNKNOWN = enum.auto()
     NEGATIVE_QUANTITY = enum.auto()
+
+
+class TimeFrame(enum.Enum):
+    """
+    Enum for timeframes.
+
+    **Attributes:**
+
+    | Enum | Value | Description |
+    |------|-------|-------------|
+    | `SECOND` | `enum.auto()` | 1 second |
+    | `MINUTE` | `enum.auto()` | 1 minute |
+    | `HOUR` | `enum.auto()` | 1 hour |
+    | `DAY` | `enum.auto()` | 1 day |
+    | `WEEK` | `enum.auto()` | 1 week |
+    | `MONTH` | `enum.auto()` | 1 month |
+    | `YEAR` | `enum.auto()` | 1 year
+    """
+
+    SECOND = enum.auto()
+    MINUTE = enum.auto()
+    HOUR = enum.auto()
+    DAY = enum.auto()
+    WEEK = enum.auto()
+    MONTH = enum.auto()
+    YEAR = enum.auto()

onesecondtrader-0.10.0/src/onesecondtrader/datafeeds/base_datafeed.py

@@ -0,0 +1,263 @@
+"""
+This module provides the base class for datafeeds.
+"""
+
+import abc
+import threading
+from onesecondtrader.messaging import eventbus
+from onesecondtrader.core import models
+from onesecondtrader.monitoring import console
+
+
+class BaseDatafeed(abc.ABC):
+    """
+    Base class for all datafeeds.
+    """
+
+    def __init__(self, event_bus: eventbus.EventBus) -> None:
+        """
+        Initializes the datafeed with the provided event bus.
+
+        Args:
+            event_bus (eventbus.EventBus): The event bus to publish events to.
+
+        Attributes:
+            self.event_bus (eventbus.EventBus): The event bus to publish events to.
+            self._lock (threading.Lock): Lock for thread safety.
+            self._is_connected (bool): Whether the datafeed is connected. `True` if
+                  connected, `False` otherwise.
+            self._streamed_symbols (set[tuple[str, models.TimeFrame]]): Set of symbols
+                 and timeframes that are currently being streamed.
+        """
+        self.event_bus = event_bus
+
+        self._lock = threading.Lock()
+        self._is_connected = False
+        self._streamed_symbols: set[tuple[str, models.TimeFrame]] = set()
+
+    def connect(self) -> bool:
+        """
+        Connect to the datafeed.
+
+        Returns:
+            bool: True if connection successful, False otherwise.
+        """
+        with self._lock:
+            if self._is_connected:
+                console.logger.warning(f"{self.__class__.__name__} already connected")
+                return True
+
+            console.logger.info(f"Connecting to {self.__class__.__name__}...")
+            try:
+                success = self._connect()
+                if success:
+                    self._is_connected = True
+                    console.logger.info(
+                        f"Successfully connected to {self.__class__.__name__}"
+                    )
+                    return True
+                else:
+                    console.logger.error(
+                        f"Failed to connect to {self.__class__.__name__}"
+                    )
+                    return False
+            except Exception as e:
+                console.logger.error(
+                    f"Connection failed for {self.__class__.__name__}: {e}"
+                )
+                return False
+
+    @abc.abstractmethod
+    def _connect(self) -> bool:
+        """
+        Implement connection logic for the specific datafeed.
+
+        Returns:
+            bool: True if connection successful, False otherwise.
+        """
+        pass
+
+    def disconnect(self) -> bool:
+        """
+        Disconnect from the datafeed.
+        Clears the set of streamed symbols.
+
+        Returns:
+            bool: True if disconnection successful, False otherwise.
+        """
+        with self._lock:
+            if not self._is_connected:
+                console.logger.warning(
+                    f"{self.__class__.__name__} already disconnected"
+                )
+                return True
+
+            console.logger.info(f"Disconnecting from {self.__class__.__name__}...")
+            try:
+                success = self._disconnect()
+                if success:
+                    self._is_connected = False
+                    self._streamed_symbols.clear()
+                    console.logger.info(
+                        f"Successfully disconnected from {self.__class__.__name__}"
+                    )
+                    return True
+                else:
+                    console.logger.error(
+                        f"Failed to disconnect from {self.__class__.__name__}"
+                    )
+                    return False
+            except Exception as e:
+                console.logger.error(
+                    f"Disconnection failed for {self.__class__.__name__}: {e}"
+                )
+                self._is_connected = False
+                self._streamed_symbols.clear()
+                return False
+
+    @abc.abstractmethod
+    def _disconnect(self) -> bool:
+        """
+        Implement disconnection logic for the specific datafeed.
+
+        Returns:
+            bool: True if disconnection successful, False otherwise.
+        """
+        pass
+
+    def start_streaming_for_symbols(
+        self, symbols: list[tuple[str, models.TimeFrame]]
+    ) -> bool:
+        """
+        Start streaming market data for the specified symbols and timeframes.
+
+        Args:
+            symbols: List of (symbol, timeframe) tuples to start streaming.
+
+        Returns:
+            bool: True if streaming started successfully, False otherwise.
+        """
+        if not symbols:
+            console.logger.warning("No symbols provided for streaming")
+            return True
+
+        with self._lock:
+            if not self._is_connected:
+                console.logger.error("Cannot start streaming: datafeed not connected")
+                return False
+
+            new_symbols = set(symbols) - self._streamed_symbols
+            if not new_symbols:
+                console.logger.info("All requested symbols are already being streamed")
+                return True
+
+            try:
+                success = self._start_streaming_for_symbols(list(new_symbols))
+                if success:
+                    self._streamed_symbols.update(new_symbols)
+                    console.logger.info(
+                        f"Successfully started streaming for {len(new_symbols)} symbols"
+                    )
+                    return True
+                else:
+                    console.logger.error("Failed to start streaming for symbols")
+                    return False
+            except Exception as e:
+                console.logger.error(f"Exception while starting streaming: {e}")
+                return False
+
+    @abc.abstractmethod
+    def _start_streaming_for_symbols(
+        self, symbols: list[tuple[str, models.TimeFrame]]
+    ) -> bool:
+        """
+        Implement streaming startup logic for the specific datafeed.
+
+        Args:
+            symbols: List of (symbol, timeframe) tuples to start streaming.
+                    These are guaranteed to be new symbols not already being streamed.
+
+        Returns:
+            bool: True if streaming started successfully, False otherwise.
+        """
+        pass
+
+    def stop_streaming_for_symbols(
+        self, symbols: list[tuple[str, models.TimeFrame]]
+    ) -> bool:
+        """
+        Stop streaming market data for the specified symbols and timeframes.
+
+        Args:
+            symbols: List of (symbol, timeframe) tuples to stop streaming.
+
+        Returns:
+            bool: True if streaming stopped successfully, False otherwise.
+        """
+        if not symbols:
+            console.logger.warning("No symbols provided for stopping streaming")
+            return True
+
+        with self._lock:
+            if not self._is_connected:
+                console.logger.warning(
+                    "Datafeed not connected, but removing symbols from tracking"
+                )
+                self._streamed_symbols.difference_update(symbols)
+                return True
+
+            symbols_to_stop = set(symbols) & self._streamed_symbols
+            if not symbols_to_stop:
+                console.logger.info(
+                    "None of the requested symbols are currently being streamed"
+                )
+                return True
+
+            console.logger.info(
+                f"Stopping streaming for {len(symbols_to_stop)} symbols"
+            )
+            try:
+                success = self._stop_streaming_for_symbols(list(symbols_to_stop))
+                if success:
+                    self._streamed_symbols.difference_update(symbols_to_stop)
+                    console.logger.info(
+                        f"Successfully stopped streaming for {len(symbols_to_stop)} "
+                        f"symbols"
+                    )
+                    return True
+                else:
+                    console.logger.error("Failed to stop streaming for symbols")
+                    return False
+            except Exception as e:
+                console.logger.error(f"Exception while stopping streaming: {e}")
+                self._streamed_symbols.difference_update(symbols_to_stop)
+                return False
+
+    @abc.abstractmethod
+    def _stop_streaming_for_symbols(
+        self, symbols: list[tuple[str, models.TimeFrame]]
+    ) -> bool:
+        """
+        Implement streaming shutdown logic for the specific datafeed.
+
+        Args:
+            symbols: List of (symbol, timeframe) tuples to stop streaming.
+                    These are guaranteed to be symbols currently being streamed.
+
+        Returns:
+            bool: True if streaming stopped successfully, False otherwise.
+        """
+        pass
+
+    @abc.abstractmethod
+    def preload_bars(
+        self, preload_list: list[tuple[str, models.TimeFrame, int]]
+    ) -> None:
+        """
+        Preload historical bars for the specified symbols, timeframes, and counts.
+
+        Args:
+            preload_list: List of (symbol, timeframe, count) tuples specifying
+                         what historical data to preload.
+        """
+        pass

onesecondtrader-0.10.0/src/onesecondtrader/messaging/eventbus.py

@@ -0,0 +1,490 @@
+"""
+This module provides the event bus for managing event-driven communication between
+ the trading infrastructure's components via a publish-subscribe messaging pattern.
+"""
+
+import collections
+import inspect
+import logging
+import threading
+from collections.abc import Callable
+from onesecondtrader.messaging import events
+from onesecondtrader.monitoring import console
+
+
+class EventBus:
+    # noinspection PyTypeChecker
+    """
+    Event bus for managing event-driven communication between the trading
+     infrastructure's components via a publish-subscribe messaging pattern.
+    Supports inheritance-based subscriptions where handlers subscribed to a parent event
+     type will receive events of child types.
+    Each subscription can include an optional filter function to receive only specific
+     events of a given type (e.g. filtering `IncomingBar` events for a specific symbol).
+
+    Examples:
+        >>> # Import necessary modules
+        >>> import pandas as pd
+        >>> from onesecondtrader.messaging.eventbus import EventBus
+        >>> from onesecondtrader.messaging import events
+        >>> from onesecondtrader.core import models
+
+        >>> # Instantiate event bus
+        >>> event_bus = EventBus()
+
+        >>> # Create a dummy handler that simply prints the symbol of the received event
+        >>> def dummy_handler(incoming_bar_event: events.Market.IncomingBar):
+        ...     print(f"Received: {incoming_bar_event.symbol}")
+
+        >>> # Subscribe to IncomingBar events whose symbol is AAPL
+        >>> event_bus.subscribe(
+        ...     events.Market.IncomingBar,
+        ...     dummy_handler,
+        ...     lambda event: event.symbol == "AAPL" # Lambda filter function
+        ... )
+
+        >>> # Create events to publish
+        >>> aapl_event = events.Market.IncomingBar(
+        ...     ts_event=pd.Timestamp("2023-01-01", tz="UTC"),
+        ...     symbol="AAPL",
+        ...     bar=models.Bar(
+        ...         open=100.0, high=101.0, low=99.0,
+        ...         close=100.5, volume=1000
+        ...     )
+        ... )
+        >>> googl_event = events.Market.IncomingBar(
+        ...     ts_event=pd.Timestamp("2023-01-01", tz="UTC"),
+        ...     symbol="GOOGL",
+        ...     bar=models.Bar(
+        ...         open=2800.0, high=2801.0, low=2799.0,
+        ...         close=2800.5, volume=500
+        ...     )
+        ... )
+
+        >>> # Publish events - only AAPL passes filter and will be printed
+        >>> event_bus.publish(aapl_event)
+        Received: AAPL
+        >>> event_bus.publish(googl_event)
+
+        >>> # Unsubscribe the dummy handler
+        >>> event_bus.unsubscribe(events.Market.IncomingBar, dummy_handler)
+
+        >>> # Publish again - no handler receives it (warning will be logged)
+        >>> event_bus.publish(aapl_event)  # doctest: +SKIP
+        WARNING:root:Published IncomingBar but no subscribers exist - check event wiring
+    """
+
+    def __init__(self) -> None:
+        """
+        Initializes the event bus with optimized data structures for high-performance
+        event publishing.
+
+        Attributes:
+            self._handlers (collections.defaultdict): Direct storage mapping event types
+                 to handler lists
+            self._publish_cache (dict): Pre-computed cache for O(1) publish operations
+            self._lock (threading.Lock): Single lock for all operations
+                (subscribe/unsubscribe are rare)
+            self._sequence_number (int): Sequence number counter for events
+        """
+        self._handlers: dict[
+            type[events.Base.Event],
+            list[
+                tuple[
+                    Callable[[events.Base.Event], None],
+                    Callable[[events.Base.Event], bool],
+                ]
+            ],
+        ] = collections.defaultdict(list)
+
+        self._publish_cache: dict[
+            type[events.Base.Event],
+            list[
+                tuple[
+                    Callable[[events.Base.Event], None],
+                    Callable[[events.Base.Event], bool],
+                ]
+            ],
+        ] = {}
+
+        self._lock: threading.Lock = threading.Lock()
+        self._sequence_number: int = -1
+
+        self._rebuild_cache()
+
+    def subscribe(
+        self,
+        event_type: type[events.Base.Event],
+        event_handler: Callable[[events.Base.Event], None],
+        event_filter: Callable[[events.Base.Event], bool] | None = None,
+    ) -> None:
+        """
+        The `subscribe` method registers an event handler for event messages of a
+         specified type and all its subtypes (expressed as subclasses in the event
+          dataclass hierarchy, so-called inheritance-based subscription).
+        When an event of that type or any subtype is published, the handler will be
+         invoked if the associated `event_filter` returns `True` for that event
+         instance.
+        A given handler can only be subscribed once per event type.
+        If the handler is already subscribed to the given event type
+         —regardless of the filter function—
+        the subscription attempt is ignored and a warning is logged.
+
+        Arguments:
+            event_type (type[events.Base.Event]): Type of the event to subscribe to,
+             must be a subclass of `events.Base.Event`.
+            event_handler (Callable[events.Base.Event, None]): Function to call when an
+                 event of the given type is published.
+                This callable must accept a single argument of type `events.Base.Event`
+                 (or its subclass).
+            event_filter (Callable[[events.Base.Event], bool] | None): Function to
+                 determine whether to call the event handler for a given event.
+                Should accept one event and return `True` to handle or `False` to
+                 ignore.
+                Defaults to `None`, which creates a filter that always returns `True`
+                 (i.e. always call the event handler).
+        """
+
+        if not issubclass(event_type, events.Base.Event):
+            console.logger.error(
+                f"Invalid subscription attempt: event_type must be a subclass of "
+                f"Event, got {type(event_type).__name__}"
+            )
+            return
+
+        if not callable(event_handler):
+            console.logger.error(
+                f"Invalid subscription attempt: event_handler must be callable, "
+                f"got {type(event_handler).__name__}"
+            )
+            return
+
+        if event_filter is None:
+
+            def event_filter(event: events.Base.Event) -> bool:
+                return True
+
+        if not callable(event_filter):
+            console.logger.error(
+                f"Invalid subscription attempt: event_filter must be callable, "
+                f"got {type(event_filter).__name__}"
+            )
+            return
+
+        is_valid, error_msg = self._validate_filter_signature(event_filter)
+        if not is_valid:
+            console.logger.error(f"Invalid subscription attempt: {error_msg}")
+            return
+
+        with self._lock:
+            if any(
+                event_handler == existing_handler
+                for existing_handler, _ in self._handlers[event_type]
+            ):
+                console.logger.warning(
+                    f"Duplicate subscription attempt: event_handler was already "
+                    f"subscribed to {event_type.__name__}"
+                )
+                return
+
+            self._handlers[event_type].append((event_handler, event_filter))
+
+            self._rebuild_cache()
+
+            handler_name = getattr(event_handler, "__name__", "<lambda>")
+            console.logger.info(f"Subscribed {handler_name} to {event_type.__name__}.")
+
+    def unsubscribe(
+        self,
+        event_type: type[events.Base.Event],
+        event_handler: Callable[[events.Base.Event], None],
+    ) -> None:
+        """
+        The `unsubscribe` method removes an event handler from the subscribers list for
+         the specified event type.
+        If the event handler is not subscribed to the given event type, the
+         unsubscription attempt is ignored and a warning is logged.
+        After removing the event handler, the event type may have an empty subscribers
+         list but remains in the `subscribers` dictionary.
+
+        Arguments:
+            event_type (type[events.Base.Event]): Type of the event to unsubscribe from,
+                 must be a subclass of `events.Base.Event`.
+            event_handler (Callable[events.Base.Event, None]): Event handler to remove
+                 from the subscribers list (this will also remove the associated filter
+                 function).
+        """
+        if not issubclass(event_type, events.Base.Event):
+            console.logger.error(
+                f"Invalid unsubscription attempt: event_type must be a subclass of "
+                f"Event, got {type(event_type).__name__}"
+            )
+            return
+
+        if not callable(event_handler):
+            console.logger.error(
+                f"Invalid unsubscription attempt: callback must be callable, "
+                f"got {type(event_handler).__name__}"
+            )
+            return
+
+        with self._lock:
+            if event_type not in self._handlers:
+                console.logger.warning(
+                    f"Attempted to unsubscribe from {event_type.__name__}, "
+                    f"but no subscribers exist"
+                )
+                return
+
+            current_handlers = self._handlers[event_type]
+            new_handlers = [
+                (existing_handler, existing_filter)
+                for existing_handler, existing_filter in current_handlers
+                if existing_handler != event_handler
+            ]
+
+            removed_count = len(current_handlers) - len(new_handlers)
+            if removed_count == 0:
+                handler_name = getattr(event_handler, "__name__", "<lambda>")
+                console.logger.warning(
+                    f"Attempted to unsubscribe {handler_name} from "
+                    f"{event_type.__name__}, but it was not subscribed"
+                )
+                return
+
+            if new_handlers:
+                self._handlers[event_type] = new_handlers
+            else:
+                # Clean up empty lists
+                del self._handlers[event_type]
+
+            self._rebuild_cache()
+
+            handler_name = getattr(event_handler, "__name__", "<lambda>")
+            console.logger.info(
+                f"Unsubscribed {handler_name} from "
+                f"{event_type.__name__} (removed {removed_count} subscription(s))"
+            )
+
+    def publish(self, event: events.Base.Event) -> None:
+        """
+        The `publish` method delivers the event to all handlers subscribed to the
+         event's type or any of its parent types (inheritance-based subscription).
+        Handlers are only called if their filter function returns True for this event.
+        Handlers are called synchronously in the order they were subscribed.
+
+        This method uses a pre-computed handler cache for O(1) lookup performance
+        and runs without locks for maximum concurrency.
+
+        Arguments:
+            event (events.Base.Event): Event to publish. Must be an instance of
+                 `events.Base.Event` or one of its subclasses.
+        """
+        if not isinstance(event, events.Base.Event):
+            console.logger.error(
+                f"Invalid publish attempt: event must be an instance of Event, "
+                f"got {type(event).__name__}"
+            )
+            return
+
+        object.__setattr__(
+            event, "event_bus_sequence_number", self._set_sequence_number()
+        )
+
+        event_type: type[events.Base.Event] = type(event)
+
+        handlers = self._publish_cache.get(event_type, [])
+
+        if not handlers:
+            console.logger.warning(
+                f"Published {event_type.__name__} but no subscribers exist - "
+                f"check event wiring"
+            )
+            return
+
+        delivered_count = 0
+        for event_handler, event_filter in handlers:
+            try:
+                should_handle = event_filter(event)
+
+                if not isinstance(should_handle, bool):
+                    handler_name = getattr(event_handler, "__name__", "<lambda>")
+                    console.logger.warning(
+                        f"Filter for handler {handler_name} returned "
+                        f"{type(should_handle).__name__}, expected bool. "
+                        f"Treating as False."
+                    )
+                    should_handle = False
+
+            except TypeError as type_error:
+                handler_name = getattr(event_handler, "__name__", "<lambda>")
+                if "takes" in str(type_error) and "positional argument" in str(
+                    type_error
+                ):
+                    console.logger.error(
+                        f"Filter for handler {handler_name} has wrong signature: "
+                        f"{type_error}"
+                    )
+                else:
+                    console.logger.exception(
+                        f"Filter function for handler {handler_name} failed "
+                        f"processing {event_type.__name__}: {type_error}"
+                    )
+                continue
+            except Exception as filter_exception:
+                handler_name = getattr(event_handler, "__name__", "<lambda>")
+                console.logger.exception(
+                    f"Filter function for handler {handler_name} failed "
+                    f"processing {event_type.__name__}: {filter_exception}"
+                )
+                continue
+
+            if should_handle:
+                try:
+                    event_handler(event)
+                    delivered_count += 1
+                except Exception as handler_exception:
+                    handler_name = getattr(event_handler, "__name__", "<lambda>")
+                    console.logger.exception(
+                        f"Handler {handler_name} failed processing "
+                        f"{event_type.__name__}: {handler_exception}"
+                    )
+
+        if delivered_count == 0:
+            console.logger.warning(
+                f"Published {event_type.__name__} but no handlers received it - "
+                f"all {len(handlers)} handler(s) filtered out the event"
+            )
+        else:
+            # Conditional debug logging to avoid string formatting overhead
+            if console.logger.isEnabledFor(logging.DEBUG):
+                console.logger.debug(
+                    f"Published {event_type.__name__} to {delivered_count} handler(s)"
+                )
+
+    @staticmethod
+    def _validate_filter_signature(
+        event_filter: Callable[[events.Base.Event], bool],
+    ) -> tuple[bool, str | None]:
+        """
+        Validate that filter function has the correct signature.
+
+        A valid filter function must:
+        - Accept exactly 1 parameter (the event)
+        - Not use *args or **kwargs
+        - Optionally return bool (if type annotated)
+
+        Arguments:
+            event_filter (Callable): The filter function to validate
+
+        Returns:
+            tuple[bool, str | None]: (is_valid, error_message)
+                is_valid: True if signature is valid, False otherwise
+                error_message: Description of the issue if invalid, None if valid
+        """
+        try:
+            sig = inspect.signature(event_filter)
+            params = list(sig.parameters.values())
+
+            if len(params) != 1:
+                return (
+                    False,
+                    f"Filter must accept exactly 1 parameter, got {len(params)}",
+                )
+
+            param = params[0]
+            if param.kind == inspect.Parameter.VAR_POSITIONAL:
+                return (
+                    False,
+                    "Filter cannot use *args - must accept exactly 1 event parameter",
+                )
+            if param.kind == inspect.Parameter.VAR_KEYWORD:
+                return (
+                    False,
+                    "Filter cannot use **kwargs - must accept exactly 1 event "
+                    "parameter",
+                )
+
+            if sig.return_annotation is not inspect.Parameter.empty:
+                if sig.return_annotation is not bool:
+                    return (
+                        False,
+                        f"Filter return type should be bool, got "
+                        f"{sig.return_annotation}",
+                    )
+
+            return True, None
+
+        except Exception as e:
+            return False, f"Could not inspect filter signature: {e}"
+
+    def _set_sequence_number(self) -> int:
+        """
+        Increment and return the event bus sequence number in a thread-safe manner.
+        """
+        with self._lock:
+            self._sequence_number += 1
+            return self._sequence_number
+
+    @staticmethod
+    def _get_all_concrete_event_types() -> list[type[events.Base.Event]]:
+        """
+        Dynamically discover all concrete event types from the events module.
+        Automatically adapts to namespace changes without code modifications.
+
+        Returns:
+            list[type[events.Base.Event]]: List of concrete event classes that can be
+                instantiated and published.
+        """
+        concrete_types = []
+
+        for attr_name in dir(events):
+            if attr_name.startswith("_"):
+                continue
+
+            attr = getattr(events, attr_name)
+
+            if not inspect.isclass(attr) or attr_name == "Base":
+                continue
+
+            for member_name, member_obj in inspect.getmembers(attr, inspect.isclass):
+                if (
+                    issubclass(member_obj, events.Base.Event)
+                    and member_obj != events.Base.Event
+                    and not inspect.isabstract(member_obj)
+                ):
+                    concrete_types.append(member_obj)
+
+        return concrete_types
+
+    def _rebuild_cache(self) -> None:
+        """
+        Rebuild the pre-computed publish cache for all concrete event types.
+        This method should be called whenever subscriptions change.
+        """
+        new_cache = {}
+        concrete_event_types = self._get_all_concrete_event_types()
+
+        for concrete_event_type in concrete_event_types:
+            handlers = []
+            seen_handler_ids = set()
+
+            for handler_type, handler_list in self._handlers.items():
+                if issubclass(concrete_event_type, handler_type):
+                    for handler, filter_func in handler_list:
+                        handler_id = id(handler)
+                        if handler_id not in seen_handler_ids:
+                            handlers.append((handler, filter_func))
+                            seen_handler_ids.add(handler_id)
+
+            if handlers:
+                new_cache[concrete_event_type] = handlers
+
+        self._publish_cache = new_cache
+
+        if console.logger.isEnabledFor(logging.DEBUG):
+            console.logger.debug(
+                f"Publish cache rebuilt: {len(new_cache)} event types cached, "
+                f"total handlers: "
+                f"{sum(len(handlers) for handlers in new_cache.values())}"
+            )