Key Concepts

// Get data for a specific symbol to analyze its price movements or trading signals.
public override void OnData(Slice slice)
{
    slice.TryGetValue(_symbol, out var myData);
}

// Get split information to adjust holdings and calculations for the asset.
public override void OnSplits(Splits splits)
{
    splits.TryGetValue(_symbol, out var split);
}

// Capture dividend events to account for income or adjust the strategy based on the dividend payout.
public override void OnDividends(Dividends dividends)
{
    dividends.TryGetValue(_symbol, out var dividend);
}

// Track events when a security changes its ticker, allowing the algorithm to adapt to these changes.
public override void OnSymbolChangedEvents(SymbolChangedEvents symbolChangedEvents)
{
    symbolChangedEvents.TryGetValue(_symbol, out var symbolChangedEvent);
}

// Handle delisting events to manage the position or adjust the strategy when the symbol is delisted.
public override void OnDelistings(Delistings delistings)
{
    delistings.TryGetValue(_symbol, out var delisting);
}

# Get data for a specific symbol to analyze its price movements or trading signals.
def on_data(self, slice: Slice) -> None:
    my_data = slice.get(self._symbol)

# Get split information to adjust holdings and calculations for the symbol.
def on_splits(self, splits: Splits) -> None:
    split = splits.get(self._symbol)
 
# Capture dividend events to account for income or adjust the strategy based on the dividend payout.
def on_dividends(self, dividends: Dividends) -> None:
    dividend = dividends.get(self._symbol)
   
# Track events when a security changes its ticker, allowing the algorithm to adapt to these changes.
def on_symbol_changed_events(self, symbol_changed_events: SymbolChangedEvents) -> None:
    symbol_changed_event = symbol_changed_events.get(self._symbol)

# Handle delisting events to manage the position or adjust the strategy when the symbol is delisted.
def on_delistings(self, delistings: Delistings) -> None:
    delisting = delistings.get(self._symbol)

// Log the universe changes.
public override void OnSecuritiesChanged(SecurityChanges changes)
{
    foreach (var security in changes.AddedSecurities)
    {
        Debug($"{Time}: Added {security.Symbol}");
    }
    foreach (var security in changes.RemovedSecurities)
    {
        Debug($"{Time}: Removed {security.Symbol}");
        
        if (security.Invested)
        {
            Liquidate(security.Symbol, "Removed from Universe");
        }
    }
}

# Log the universe changes.
def on_securities_changed(self, changes: SecurityChanges) -> None:
    for security in changes.added_securities:
        self.debug(f"{self.time}: Added {security.symbol}")

    for security in changes.removed_securities:
        self.debug(f"{self.time}: Removed {security.symbol}")
        
        if security.invested:
            self.liquidate(security.symbol, "Removed from Universe")

// Track filled orders and get the details of each fill.
public override void OnOrderEvent(OrderEvent orderEvent)
{
    var order = Transactions.GetOrderById(orderEvent.OrderId);
    if (orderEvent.Status == OrderStatus.Filled)
    {
        Debug($"{Time}: {order.Type}: {orderEvent}");
    }
}

// Track Option assignment events to handle assigned Equity holdings. 
public override void OnAssignmentOrderEvent(OrderEvent assignmentEvent)
{
    Log(assignmentEvent.ToString());
}

# Track filled orders and get the details of each fill.
def on_order_event(self, order_event: OrderEvent) -> None:
    order = self.transactions.get_order_by_id(order_event.order_id)
    if order_event.status == OrderStatus.FILLED:
        self.debug(f"{self.time}: {order.type}: {order_event}")

# Track Option assignment events to handle assigned Equity holdings. 
def on_assignment_order_event(self, assignment_event: OrderEvent) -> None:
    self.log(str(assignment_event))

// Track brokerage messages.
public override void OnBrokerageMessage(BrokerageMessageEvent message)
{
    if (message.Type== BrokerageMessageType.Reconnect)
    {
        Log($"{Time}: {message.Type}: Message: {message.Message}");
    }
}

// Track brokerage disconnections and respond to connectivity interruptions.
public override void OnBrokerageDisconnect()
{
    Log($"Brokerage disconnection detected at {Time}.");
}

// Track brokerage reconnections to resume trading operations.
public override void OnBrokerageReconnect()
{
    Log($"Brokerage reconnected at {Time}.");
}

# Track brokerage messages.
def on_brokerage_message(self, message: BrokerageMessageEvent) -> None: 
    if message.type == BrokerageMessageType.RECONNECT:
        self.log(f"{self.time}: {message.type}: Message: {message.message}")

# Track brokerage disconnections and respond to connectivity interruptions.
def on_brokerage_disconnect(self) -> None:
    self.log(f"Brokerage disconnection detected at {self.time}")

 # Track brokerage reconnections to resume trading operations.
def on_brokerage_reconnect(self) -> None:
    self.log(f"Brokerage reconnected at {self.time}")