py-backtesting-lib 0.1.0__py3-none-any.whl

Backtesting/definition/plugins/base_interfaces.py

@@ -0,0 +1,126 @@
+# Backtesting/definition/plugins/base_interfaces.py
+
+from abc import ABC, abstractmethod
+from typing import List, Iterator
+from ..core.domain_models import Signal, Order, Fill, MarketBar # Import from the new core module
+
+
+# --- Strategy Interface ---
+class Strategy(ABC):
+    """
+    Abstract base class for trading strategies.
+    Strategies receive market data and emit Signals.
+    """
+    @abstractmethod
+    def on_data(self, bar: MarketBar) -> List[Signal]:
+        """
+        Called by the execution engine when new market data arrives.
+        Should return a list of Signals based on the data.
+        """
+        pass
+
+    @abstractmethod
+    def initialize(self, config: dict): # Consider using Pydantic models instead of raw dict later
+        """
+        Called once at the beginning of the experiment to set up the strategy.
+        """
+        pass
+
+    @abstractmethod
+    def reset(self):
+        """
+        Called to reset the strategy's internal state (e.g., for multiple runs).
+        """
+        pass
+
+
+# --- Money Manager Interface ---
+class MoneyManager(ABC):
+    """
+    Abstract base class for money/risk management logic.
+    MoneyManagers take Signals and convert them into Orders based on risk rules.
+    """
+    @abstractmethod
+    def size_order(self, signal: Signal, current_portfolio_state: dict) -> List[Order]: # Simplified state dict for now
+        """
+        Takes a Signal and current portfolio state, returns a list of Orders.
+        Could return an empty list to reject the signal.
+        """
+        pass
+
+    @abstractmethod
+    def initialize(self, config: dict):
+        """
+        Called once at the beginning of the experiment.
+        """
+        pass
+
+    @abstractmethod
+    def reset(self):
+        """
+        Called to reset the MM's state.
+        """
+        pass
+
+
+# --- Broker Interface ---
+class Broker(ABC):
+    """
+    Abstract base class for broker simulation.
+    Brokers take Orders and simulate their execution (Fills).
+    """
+    @abstractmethod
+    def process_order(self, order: Order, current_market_bar: MarketBar) -> List[Fill]: # Could also return updated Order status
+        """
+        Simulates the execution of an order against the current market bar.
+        Returns a list of Fills (could be empty if not filled).
+        """
+        pass
+
+    @abstractmethod
+    def initialize(self, config: dict):
+        """
+        Called once at the beginning of the experiment.
+        """
+        pass
+
+    @abstractmethod
+    def reset(self):
+        """
+        Called to reset the broker's state (e.g., open orders).
+        """
+        pass
+
+
+# --- Reporter Interface (Bonus, though mentioned in docs) ---
+class Reporter(ABC):
+    """
+    Abstract base class for analysis/reporting plugins.
+    Reporters process the final ExperimentResult.
+    """
+    @abstractmethod
+    def generate_report(self, result_data: dict): # Or accept ExperimentResult object directly
+        """
+        Processes the final result data and generates a report/metrics.
+        """
+        pass
+
+    @abstractmethod
+    def initialize(self, config: dict):
+        """
+        Initialize the reporter.
+        """
+        pass
+
+
+class MarketDataProvider(ABC):
+    """
+    Abstract base class for market data providers.
+    Providers yield historical or live market data bars.
+    """
+    @abstractmethod
+    def get_bars(self) -> Iterator[MarketBar]:
+        """
+        Yields MarketBar objects.
+        """
+        pass

Backtesting/definition/plugins/plugin_registry.py

@@ -0,0 +1,26 @@
+from typing import Type, Dict, Any
+# Import the new MarketDataProvider interface
+from .base_interfaces import Strategy, MoneyManager, Broker, Reporter, MarketDataProvider
+
+_REGISTRY: Dict[str, Type[Any]] = {}
+
+
+class PluginNotFoundError(Exception):
+    pass
+
+
+def register(plugin_name: str, plugin_class: Type[Any]):
+    if plugin_name in _REGISTRY:
+        raise ValueError(f"Plugin name '{plugin_name}' is already registered.")
+
+    if not issubclass(plugin_class, (Strategy, MoneyManager, Broker, Reporter, MarketDataProvider)):
+        raise TypeError(f"Class {plugin_class} does not inherit from a known plugin base interface.")
+
+    _REGISTRY[plugin_name] = plugin_class
+    print(f"DEBUG: Registered plugin '{plugin_name}' -> {plugin_class}")
+
+
+def resolve(plugin_name: str) -> Type[Any]:
+    if plugin_name not in _REGISTRY:
+        raise PluginNotFoundError(f"Plugin '{plugin_name}' not found in registry.")
+    return _REGISTRY[plugin_name]

Backtesting/execution/__init__.py

@@ -0,0 +1,22 @@
+# Backtesting/execution/__init__.py
+
+from .engine import ExecutionEngine
+from .market_data import MarketDataProvider, create_dummy_market_data
+from .pipeline import ExecutionPipeline
+from .event import EventBus
+from ..definition import Trade
+from .books import OrderBook, PositionBook, TradeBook
+from .portfolio import Portfolio
+
+__all__ = [
+    "ExecutionEngine",
+    "MarketDataProvider",
+    "create_dummy_market_data",
+    "ExecutionPipeline",
+    "EventBus",
+    "OrderBook",
+    "PositionBook",
+    "TradeBook",
+    "Portfolio",
+    "Trade"
+]

Backtesting/execution/books/__init__.py

@@ -0,0 +1,11 @@
+from .order_book import OrderBook, MutableOrder
+from .position_book import PositionBook, Position
+from .trade_book import TradeBook
+
+__all__ = [
+    "OrderBook",
+    "MutableOrder",
+    "PositionBook",
+    "Position",
+    "TradeBook",
+]

Backtesting/execution/books/order_book.py

@@ -0,0 +1,130 @@
+
+from typing import Dict, List
+from decimal import Decimal
+from ...definition import Order as EventOrder, Fill as EventFill, OrderStatus, OrderSide, OrderType
+from dataclasses import dataclass
+
+# --- Mutable Runtime Order Object ---
+@dataclass
+class MutableOrder:
+    """A mutable version of Order used internally by OrderBook to track state."""
+    order_id: str
+    signal_id: str
+    symbol: str
+    order_type: OrderType
+    side: OrderSide
+    quantity: Decimal
+    price: Decimal = None
+    stop_price: Decimal = None
+    status: OrderStatus = OrderStatus.SUBMITTED # Use the enum from models
+    filled_quantity: Decimal = Decimal('0')
+    average_fill_price: Decimal = Decimal('0')
+    commission: Decimal = Decimal('0')
+
+    def update_from_event_order(self, event_order: EventOrder):
+        """Updates this mutable order's state from an event order."""
+        # This might be used if the initial order submission comes as an event
+        # For now, OrderBook.add_order might just take the event_order and convert it.
+        pass
+
+    def to_event_order(self) -> EventOrder:
+        """Converts this mutable order back to an immutable event order if needed."""
+        # Useful for publishing state changes or logging
+        return EventOrder(
+            order_id=self.order_id,
+            signal_id=self.signal_id,
+            symbol=self.symbol,
+            order_type=self.order_type,
+            side=self.side,
+            quantity=self.quantity,
+            price=self.price,
+            stop_price=self.stop_price,
+            status=self.status,
+            filled_quantity=self.filled_quantity,
+            average_fill_price=self.average_fill_price,
+            commission=self.commission
+        )
+
+# --- OrderBook Implementation ---
+class OrderBook:
+    """
+    Tracks the lifecycle of orders (submitted, pending, filled, cancelled).
+    State is updated only via the apply_* methods, driven by events from the EventBus.
+    Uses a mutable internal representation for tracking state changes during execution.
+    """
+
+    def __init__(self):
+        # Dictionary mapping order_id to the MutableOrder object
+        self._orders: Dict[str, MutableOrder] = {}
+
+    def add_order(self, order: EventOrder):
+        """Add a new order to the book."""
+        if order.order_id in self._orders:
+            # This could happen if an event is processed twice or there's a bug
+            print(f"Warning: Order ID {order.order_id} already exists in OrderBook.")
+            return
+        # Convert immutable event order to mutable internal representation
+        mutable_order = MutableOrder(
+            order_id=order.order_id,
+            signal_id=order.signal_id,
+            symbol=order.symbol,
+            order_type=order.order_type,
+            side=order.side,
+            quantity=order.quantity,
+            price=order.price,
+            stop_price=order.stop_price,
+            status=order.status,
+            filled_quantity=order.filled_quantity,
+            average_fill_price=order.average_fill_price,
+            commission=order.commission
+        )
+        self._orders[order.order_id] = mutable_order
+        print(f"DEBUG: Added order {order.order_id} to OrderBook.")
+
+    def cancel_order(self, order_id: str):
+        """Cancel an existing order."""
+        if order_id in self._orders:
+            order = self._orders[order_id]
+            order.status = OrderStatus.CANCELLED # Modify the mutable state
+            print(f"DEBUG: Cancelled order {order_id}.")
+        else:
+            print(f"Warning: Attempted to cancel non-existent order {order_id}.")
+
+    def apply_fill(self, fill: EventFill):
+        """
+        Applies a Fill event to update the corresponding mutable order's state.
+        """
+        order_id = fill.order_id
+        if order_id not in self._orders:
+            print(f"Warning: Fill received for unknown order {order_id}. Skipping.")
+            return
+
+        order = self._orders[order_id]
+        # Update filled quantity and average fill price based on the new fill
+        total_filled_qty = order.filled_quantity + fill.quantity
+        total_cost = (order.filled_quantity * order.average_fill_price) + (fill.quantity * fill.fill_price)
+
+        order.filled_quantity = total_filled_qty
+        if total_filled_qty > 0: # Avoid division by zero
+            order.average_fill_price = total_cost / total_filled_qty
+
+        # Determine if the order is fully filled
+        if total_filled_qty >= order.quantity:
+            order.status = OrderStatus.FILLED # Modify the mutable state
+            print(f"DEBUG: Order {order.order_id} is now FILLED.")
+        else:
+            order.status = OrderStatus.PARTIALLY_FILLED # Modify the mutable state
+            print(f"DEBUG: Order {order.order_id} is PARTIALLY_FILLED. {total_filled_qty}/{order.quantity}")
+
+
+    def get_open_orders(self) -> List[MutableOrder]:
+        """Returns a list of orders that are not fully filled or cancelled."""
+        return [order for order in self._orders.values() if order.status in (OrderStatus.SUBMITTED, OrderStatus.PENDING, OrderStatus.PARTIALLY_FILLED)]
+
+    def get_order(self, order_id: str) -> MutableOrder:
+        """Retrieve an order by its ID."""
+        return self._orders.get(order_id)
+
+    def get_order_by_event(self, order_id: str) -> MutableOrder: # Updated signature to take ID
+        """Helper to get the mutable order corresponding to an event order ID."""
+        return self._orders.get(order_id)

Backtesting/execution/books/position_book.py

@@ -0,0 +1,136 @@
+
+from typing import Dict, Optional
+from decimal import Decimal
+from ...definition import Fill as EventFill, MarketBar as EventMarketBar, OrderSide
+
+class Position:
+    """
+    Represents an open position for a specific symbol.
+    Stores average entry price and net size (positive for long, negative for short).
+    """
+    def __init__(self, symbol: str):
+        self.symbol = symbol
+        self.avg_entry_price: Decimal = Decimal('0')
+        self.net_size: Decimal = Decimal('0')
+        self.unrealized_pnl: Decimal = Decimal('0')
+
+    def update_from_fill(self, fill: EventFill):
+        """
+        Updates the position based on a Fill event.
+        Handles both opening/increasing and closing/decreasing the position.
+        """
+        if fill.symbol != self.symbol:
+            raise ValueError(f"Fill symbol {fill.symbol} does not match position symbol {self.symbol}")
+
+        old_net_size = self.net_size
+        old_avg_price = self.avg_entry_price
+
+        # Calculate new net size
+        direction_multiplier = 1 if fill.side == OrderSide.BUY else -1
+        fill_size = fill.quantity * direction_multiplier
+        new_net_size = self.net_size + fill_size
+
+        if new_net_size == 0:
+            # Position is fully closed
+            self.net_size = Decimal('0') # <-- FIX: Set net_size to 0 first
+            self.avg_entry_price = Decimal('0')
+            # Realized PnL was calculated and handled by TradeBook or Portfolio logic upon closure
+            # Here, Unrealized PnL becomes 0 as the position is gone.
+            self.unrealized_pnl = Decimal('0')
+            print(f"DEBUG: Position for {self.symbol} fully closed.")
+        elif (old_net_size > 0 and new_net_size < 0) or (old_net_size < 0 and new_net_size > 0):
+            # Position reversed direction (e.g., Long 100 -> Sell 150 -> Short 50)
+            # Cost basis resets based on the remaining size after closing the original position
+            # For simplicity in this model, we assume FIFO for reversal, meaning the original position is closed first.
+            # However, true FIFO requires tracking individual lots. This simplified version recalculates average.
+            # Let's recalculate based on the new side's fills contributing to the new average.
+            # New average price calculation after reversal is complex. Simplifying:
+            # Assume the old position is closed at the fill price, and the new position starts fresh.
+            # This is a simplification. A full FIFO model would be needed for exact lot tracking.
+            # For now, let's adjust average price if the sign changed due to the fill.
+            if (old_net_size > 0 and fill.side == OrderSide.SELL) or (old_net_size < 0 and fill.side == OrderSide.BUY):
+                 # Closing part/all of existing position first
+                 qty_to_close = min(abs(old_net_size), fill.quantity)
+                 realized_pnl_from_close = qty_to_close * (fill.fill_price - old_avg_price) * (1 if old_net_size > 0 else -1)
+                 # The remaining fill quantity opens a new position on the opposite side
+                 remaining_fill_qty = fill.quantity - qty_to_close
+                 if remaining_fill_qty > 0:
+                      self.avg_entry_price = fill.fill_price
+                      self.net_size = remaining_fill_qty * direction_multiplier
+                 else:
+                     # Exact close, net_size should be 0, handled above
+                     pass
+            else: # Opening more of the same side or starting new after reversal
+                 total_value = (self.net_size * self.avg_entry_price) + (fill_size * fill.fill_price)
+                 self.avg_entry_price = total_value / new_net_size if new_net_size != 0 else Decimal('0')
+                 self.net_size = new_net_size
+        else:
+            # Same direction or increasing/decreasing without crossing zero
+            total_value = (self.net_size * self.avg_entry_price) + (fill_size * fill.fill_price)
+            self.avg_entry_price = total_value / new_net_size if new_net_size != 0 else Decimal('0')
+            self.net_size = new_net_size
+
+        print(f"DEBUG: Position {self.symbol} updated: Size {self.net_size}, Avg Price {self.avg_entry_price}")
+
+    def update_unrealized_pnl(self, current_market_price: Decimal):
+        """
+        Updates the unrealized PnL based on the current market price.
+        """
+        if self.net_size == 0:
+            self.unrealized_pnl = Decimal('0')
+        else:
+            price_diff = current_market_price - self.avg_entry_price
+            self.unrealized_pnl = self.net_size * price_diff
+        print(f"DEBUG: Position {self.symbol} UPL updated to {self.unrealized_pnl} at market price {current_market_price}")
+
+
+class PositionBook:
+    """
+    Manages open positions per symbol.
+    State is updated only via the apply_* methods, driven by events from the EventBus.
+    """
+    def __init__(self):
+        # Dictionary mapping symbol to Position object
+        self._positions: Dict[str, Position] = {}
+
+    def apply_fill(self, fill: EventFill):
+        """
+        Applies a Fill event to update the corresponding position.
+        If no position exists for the symbol, a new one is created.
+        """
+        symbol = fill.symbol
+        if symbol not in self._positions:
+            if fill.quantity == 0:
+                print(f"Warning: Fill with zero quantity for new symbol {symbol}. Ignoring.")
+                return
+            # Create new position if none exists
+            self._positions[symbol] = Position(symbol)
+
+        position = self._positions[symbol]
+        position.update_from_fill(fill)
+
+        # Check if position was closed (net_size became 0)
+        if position.net_size == 0:
+            del self._positions[symbol] # Remove the position object if closed
+            print(f"DEBUG: Removed closed position for {symbol} from PositionBook.")
+
+
+    def update_market_price(self, bar: EventMarketBar):
+        """
+        Updates the unrealized PnL for the position in the symbol represented by the market bar.
+        """
+        symbol = bar.symbol
+        if symbol in self._positions:
+            position = self._positions[symbol]
+            # Using 'close' price as the current market price for marking to market
+            position.update_unrealized_pnl(Decimal(str(bar.close)))
+        else:
+            print(f"DEBUG: No position for symbol {bar.symbol} to update UPL.")
+
+    def get_position(self, symbol: str) -> Optional[Position]:
+        """Retrieve the position for a given symbol."""
+        return self._positions.get(symbol)
+
+    def get_all_positions(self) -> Dict[str, Position]:
+        """Get a dictionary of all open positions."""
+        return self._positions.copy() # Return a shallow copy to prevent external modification

Backtesting/execution/books/trade_book.py

@@ -0,0 +1,88 @@
+
+from typing import Dict, List
+from decimal import Decimal
+from dataclasses import dataclass
+from ...definition import Fill as EventFill, Order as EventOrder, OrderSide # Import event versions
+
+@dataclass(frozen=True) # Use frozen dataclass for immutability
+class Trade:
+    """
+    Represents an immutable record of a closed trade.
+    """
+    symbol: str
+    entry_time: Decimal # Or datetime if available in fill
+    exit_time: Decimal  # Or datetime if available in fill
+    entry_price: Decimal
+    exit_price: Decimal
+    quantity: Decimal
+    side: str # 'LONG' or 'SHORT' based on entry side
+    realized_pnl: Decimal
+    commission: Decimal
+
+class TradeBook:
+    """
+    Archives closed trades as immutable Trade records.
+    State is updated only via the apply_* methods, driven by events from the EventBus.
+    """
+    def __init__(self):
+        self._trades: List[Trade] = []
+
+    def apply_fill(self, fill: EventFill, order: EventOrder, position_before_fill: Decimal, position_after_fill: Decimal, entry_price: Decimal):
+        """
+        Applies a Fill event. If the fill results in a position being closed (crossing zero),
+        an immutable Trade record is created and stored.
+
+        Args:
+            fill: The fill event.
+            order: The order associated with the fill (for commission).
+            position_before_fill: Net size of the position *before* this fill was applied.
+            position_after_fill: Net size of the position *after* this fill was applied.
+            entry_price: The average entry price of the position being closed.
+                        This should come from the PositionBook *before* the fill is applied.
+        """
+        # Determine if this fill closed part or all of an existing position
+        # A trade is considered "closed" when the net position crosses zero or reaches zero
+        # due to this fill.
+
+        # Scenario 1: Position was open, fill closes it entirely or partially towards zero
+        # Scenario 2: Position was open, fill reverses the position (closes old, opens new)
+        # Scenario 3: No position existed, fill opens a new one (doesn't close anything)
+
+        # We need to know the *change* in position size caused by this fill
+        fill_size = fill.quantity if fill.side == OrderSide.BUY else -fill.quantity
+
+        # Check if the fill crossed the zero line (closed the position)
+        if (position_before_fill > 0 and position_after_fill <= 0) or (position_before_fill < 0 and position_after_fill >= 0):
+             # This fill resulted in closing the existing position.
+             # Determine the quantity that actually closed the old position.
+             # For simplicity, assume FIFO for closing. The quantity closed is the minimum
+             # of the fill quantity and the absolute size of the position before the fill.
+             qty_closing_existing = min(abs(position_before_fill), fill.quantity)
+
+             # Calculate entry details (using the provided entry_price from the position)
+             exit_price = fill.fill_price
+             # Realized PnL is calculated based on the entry and exit prices for the quantity closed
+             realized_pnl_for_closed_qty = qty_closing_existing * (exit_price - entry_price) * (1 if position_before_fill > 0 else -1)
+             # Commission allocation: simplest is to allocate proportionally based on quantity closed vs order quantity
+             commission_for_closed_qty = (order.commission / order.quantity) * qty_closing_existing if order.quantity > 0 else Decimal('0') # Assuming commission scales linearly
+
+             # Create the Trade record
+             # Note: Using fill timestamps for simplicity. More accurate entry/exit times require more state tracking.
+             trade = Trade(
+                 symbol=fill.symbol,
+                 entry_time=Decimal('0'), # Placeholder - need entry fill time
+                 exit_time=Decimal('0'), # Placeholder - need exit fill time
+                 entry_price=entry_price, # <-- FIX: Use the provided entry_price
+                 exit_price=exit_price,
+                 quantity=qty_closing_existing,
+                 side='LONG' if position_before_fill > 0 else 'SHORT',
+                 realized_pnl=realized_pnl_for_closed_qty - commission_for_closed_qty, # Subtract commission
+                 commission=commission_for_closed_qty
+             )
+             self._trades.append(trade)
+             print(f"DEBUG: Archived Trade: {trade}")
+
+
+    def get_closed_trades(self) -> List[Trade]:
+        """Returns a list of all closed trades."""
+        return self._trades.copy() # Return a shallow copy to prevent external modification

Backtesting/execution/engine.py

@@ -0,0 +1,57 @@
+# Backtesting/execution/engine.py
+# The main execution engine orchestrating the event loop
+
+from decimal import Decimal
+from .pipeline import ExecutionPipeline
+from .market_data import MarketDataProvider
+from Backtesting.execution.event import EventBus
+from .books import OrderBook, PositionBook, TradeBook
+from .portfolio import Portfolio
+from ..definition.plugins import Strategy, MoneyManager, Broker # Import plugin interfaces
+
+class ExecutionEngine:
+    """
+    The main orchestrator of the backtesting event loop.
+    Iterates over market data and delegates processing to the ExecutionPipeline.
+    Enforces determinism and fail-fast behavior.
+    """
+    def __init__(self, strategy: Strategy, money_manager: MoneyManager, broker: Broker,
+                 initial_cash: Decimal, market_data_provider: MarketDataProvider):
+        self.event_bus = EventBus()
+        self.order_book = OrderBook()
+        self.position_book = PositionBook()
+        self.trade_book = TradeBook()
+        self.portfolio = Portfolio(initial_cash)
+
+        self.pipeline = ExecutionPipeline(
+            strategy=strategy,
+            money_manager=money_manager,
+            broker=broker,
+            order_book=self.order_book,
+            position_book=self.position_book,
+            trade_book=self.trade_book,
+            portfolio=self.portfolio,
+            event_bus=self.event_bus
+        )
+        self.market_data_provider = market_data_provider
+
+    def run(self):
+        """
+        Executes the main event loop: iterate over bars, process each through the pipeline.
+        """
+        for bar in self.market_data_provider.get_bars():
+            # Process the bar through the entire pipeline
+            try:
+                self.pipeline.process_bar(bar)
+            except Exception as e:
+                # Fail-fast: Stop execution immediately if any plugin throws an unexpected error
+                print(f"ExecutionEngine halted due to error in pipeline: {e}")
+                raise # Re-raise to propagate the error up the call stack
+
+        # After loop completes, print final summary
+        print("\n--- Execution Summary ---")
+        print(f"Final Cash: {self.portfolio.cash}")
+        print(f"Final Equity: {self.portfolio.get_equity(self.position_book)}")
+        print(f"Open Positions: {len(self.position_book.get_all_positions())}")
+        print(f"Closed Trades: {len(self.trade_book.get_closed_trades())}")
+        print(f"Total Events Published: {len(self.event_bus._handlers)}") # This count is approximate, counts handler lists, not events published

Backtesting/execution/event.py

@@ -0,0 +1,44 @@
+
+from typing import Type, Callable, Dict, List, Any
+
+class EventBus:
+    """
+    A synchronous, in-memory Pub/Sub system for dispatching domain events.
+    Handlers are called in the order they were subscribed.
+    """
+    def __init__(self):
+        # Dictionary mapping event type to a list of handler functions
+        self._handlers: Dict[Type[Any], List[Callable[[Any], None]]] = {}
+
+    def subscribe(self, event_type: Type[Any], handler: Callable[[Any], None]):
+        """Subscribe a handler function to a specific event type."""
+        if event_type not in self._handlers:
+            self._handlers[event_type] = []
+        self._handlers[event_type].append(handler)
+        print(f"DEBUG: Subscribed handler {handler.__name__} to event {event_type.__name__}")
+
+    def unsubscribe(self, event_type: Type[Any], handler: Callable[[Any], None]):
+        """Unsubscribe a handler function from a specific event type."""
+        if event_type in self._handlers:
+            try:
+                self._handlers[event_type].remove(handler)
+                print(f"DEBUG: Unsubscribed handler {handler.__name__} from event {event_type.__name__}")
+            except ValueError:
+                print(f"Handler {handler.__name__} was not subscribed to {event_type.__name__}.")
+
+    def publish(self, event: Any):
+        """Publish an event to all subscribed handlers."""
+        event_type = type(event)
+        print(f"DEBUG: Publishing event {event_type.__name__}: {event}")
+
+        # Find handlers for the specific event type
+        specific_handlers = self._handlers.get(event_type, [])
+        for handler in specific_handlers:
+            handler(event)
+
+        # Also find handlers for parent types (polymorphism)
+        for registered_type in self._handlers:
+            if issubclass(event_type, registered_type) and registered_type != event_type:
+                parent_handlers = self._handlers[registered_type]
+                for handler in parent_handlers:
+                    handler(event)