QuantConnect

from AlgorithmImports import *

class PaymentAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(1998,1,1)

        # this will use the Tradier Brokerage open order split behavior
        # forward split will modify open order to maintain order value
        # reverse split open orders will be canceled
        self.set_brokerage_model(BrokerageName.TRADIER_BROKERAGE)

        self.universe_settings.resolution = Resolution.DAILY
        self.universe_settings.data_normalization_mode = DataNormalizationMode.RAW
        
        # MSFT: Splits and Dividends
        # GOOG: Symbol Changed Event
        # AAA.1: Delisting
        
        self.set_universe_selection(ManualUniverseSelectionModel(
            Symbol.create("MSFT", SecurityType.EQUITY, Market.USA)))

        self.set_alpha(PaymentAlphaModel())
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())
        self.set_execution(BracketExecutionModel())
            
class PaymentAlphaModel(AlphaModel):

    symbol = Symbol.EMPTY
    
    def update(self, algorithm: QCAlgorithm, slice: Slice) -> List[Insight]:
        # Accessing Data - Splits
        split = slice.splits.get(self.symbol)
        if split:
            algorithm.debug(f"{algorithm.time} >> SPLIT >> {split.symbol} - {split.split_factor} - {algorithm.portfolio.cash} - {algorithm.portfolio[self.symbol].price}")

        # Accessing Data - Dividends
        dividend = slice.dividends.get(self.symbol)
        if dividend:
            algorithm.debug(f"{algorithm.time} >> DIVIDEND >> {dividend.symbol} - {dividend.distribution} - {algorithm.portfolio.cash} - {algorithm.portfolio[self.symbol].price}")

        # Accessing Data - Delistings
        delisting = slice.delistings.get(self.symbol)
        if delisting:
            delistingType = {0: "Warning", 1: "Delisted"}.get(delisting.type)
            algorithm.debug(f"{algorithm.time} >> DELISTING >> {delisting.symbol} - {delistingType}")

        # Accessing Data - Symbol Changed Events
        symbolChangedEvent = slice.symbol_changed_events.get(self.symbol)
        if symbolChangedEvent:
            algorithm.debug(f"{algorithm.time} >> SYMBOL CHANGED >> {symbolChangedEvent.old_symbol} -> {symbolChangedEvent.new_symbol}")

        bar = slice.bars.get(self.symbol)
        return [Insight.price(self.symbol, timedelta(1), InsightDirection.UP)] if bar else []

    def on_securities_changed(self, algorithm: QCAlgorithm, changes: SecurityChanges) -> None:
        self.symbol = list(changes.added_securities)[0].symbol

class BracketExecutionModel(ExecutionModel):
    
    def __init__(self) -> None:
        '''Initializes a new instance of the ImmediateExecutionModel class'''
        self.targets_collection = PortfolioTargetCollection()

    def execute(self, algorithm: QCAlgorithm, targets: List[PortfolioTarget]) -> None:

        # for performance we check count value, OrderByMarginImpact and ClearFulfilled are expensive to call
        self.targets_collection.add_range(targets)
        if self.targets_collection.count > 0:
            for target in self.targets_collection.order_by_margin_impact(algorithm):
                # calculate remaining quantity to be ordered
                quantity = OrderSizing.get_unordered_quantity(algorithm, target)
                if quantity != 0 and algorithm.transactions.orders_count == 0:
                    bar = algorithm.securities[target.symbol].get_last_data()
                    algorithm.market_order(target.symbol, quantity)
                    # place some orders that won't fill, when the split comes in they'll get modified to reflect the split
                    algorithm.stop_market_order(target.symbol, -quantity, bar.low/2)
                    algorithm.limit_order(target.symbol, -quantity, bar.high*2)

            self.targets_collection.clear_fulfilled(algorithm)

public class PaymentsAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(1998, 01, 01);
            
        // this will use the Tradier Brokerage open order split behavior
        // forward split will modify open order to maintain order value
        // reverse split open orders will be canceled
        SetBrokerageModel(BrokerageName.TradierBrokerage);
        
        UniverseSettings.Resolution = Resolution.Daily;
        UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
        
        // MSFT: Splits and Dividends
        // GOOG: Symbol Changed Event
        // AAA.1: Delisting
        SetUniverseSelection(new ManualUniverseSelectionModel(
            QuantConnect.Symbol.Create("MSFT", SecurityType.Equity, Market.USA)));

        SetAlpha(new PaymentAlphaModel());
        SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
        SetExecution(new BracketExecutionModel());
    }
}

public class PaymentAlphaModel : AlphaModel
{
    private Symbol _symbol = Symbol.Empty;
    
    public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice slice)
    {
        // Accessing Data - Splits
        if (slice.Splits.ContainsKey(_symbol))
        {
            var split = slice.Splits[_symbol];
            algorithm.Debug($"{split.Time.ToIso8601Invariant()} >> SPLIT >> {split.Symbol} - " +
                $"{split.SplitFactor.ToStringInvariant()} - " +
                $"{algorithm.Portfolio.Cash.ToStringInvariant()} - " +
                $"{algorithm.Portfolio[_symbol].Quantity.ToStringInvariant()}");
        }
        
        // Accessing Data - Dividends
        if (slice.Dividends.ContainsKey(_symbol))
        {
            var dividend = slice.Dividends[_symbol];
            algorithm.Debug($"{dividend.Time.ToStringInvariant("o")} >> DIVIDEND >> {dividend.Symbol} - " +
                $"{dividend.Distribution.ToStringInvariant("C")} - {algorithm.Portfolio.Cash} - " +
                $"{algorithm.Portfolio[_symbol].Price.ToStringInvariant("C")}");
        }

        // Accessing Data - Delisting
        if (slice.Delistings.ContainsKey(_symbol))
        {
            var delisting = slice.Delistings[_symbol];
            algorithm.Debug($"{delisting.Time.ToStringInvariant("o")} >> DELISTING >> {delisting.Type}");
        }

        // Accessing Data - Symbol Changed Event
        if (slice.SymbolChangedEvents.ContainsKey(_symbol))
        {
            var symbolChangedEvent = slice.SymbolChangedEvents[_symbol];
            algorithm.Debug($"{symbolChangedEvent.Time.ToStringInvariant("o")} >> Symbol Changed Event >> " +
                $"{symbolChangedEvent.OldSymbol} -> {symbolChangedEvent.OldSymbol}");
        }
        
        return slice.Bars.ContainsKey(_symbol)
            ? new [] { Insight.Price(_symbol, TimeSpan.FromDays(1), InsightDirection.Up) }
            : Enumerable.Empty<Insight>();
    }
    
    public override void OnSecuritiesChanged(QCAlgorithm algorithm, SecurityChanges changes)
    {
        _symbol = changes.AddedSecurities.First().Symbol;
    }
}

public class BracketExecutionModel : ExecutionModel
{
    private readonly PortfolioTargetCollection _targetsCollection = new PortfolioTargetCollection();

    public override void Execute(QCAlgorithm algorithm, IPortfolioTarget[] targets)
    {
        _targetsCollection.AddRange(targets);
        // for performance we check count value, OrderByMarginImpact and ClearFulfilled are expensive to call
        if (_targetsCollection.Count > 0)
        {
            foreach (var target in _targetsCollection.OrderByMarginImpact(algorithm))
            {
                // calculate remaining quantity to be ordered
                var quantity = OrderSizing.GetUnorderedQuantity(algorithm, target);
                if (quantity != 0 && algorithm.Transactions.OrdersCount == 0)
                {
                    var bar = algorithm.Securities[target.Symbol].GetLastData() as TradeBar;
                    algorithm.MarketOrder(target.Symbol, quantity);
                    // place some orders that won't fill, when the split comes in they'll get modified to reflect the split
                    algorithm.StopMarketOrder(target.Symbol, -quantity, bar.Low/2);
                    algorithm.LimitOrder(target.Symbol, -quantity, bar.High*2);
                }
            }

            _targetsCollection.ClearFulfilled(algorithm);
        }
    }
}