Consolidating Data

public class ConsolidatorHistoryAlgorithm : QCAlgorithm
{
    private Symbol _spy;
    // To hold 3 consolidated trade bars to identify a breakout pattern.
    private RollingWindow<TradeBar> _windows = new(3);

    public override void Initialize()
    {
        SetStartDate(2021, 10, 1);
        SetEndDate(2022, 1, 1);
        
        // Request SPY data for signal generation and trading.
        _spy = AddEquity("SPY", Resolution.Minute).Symbol;

        // The breakout is based on a 5-minute consolidated trade bar.
        var consolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(5));
        // Subscribe for automatically updating the consolidator with SPY data.
        SubscriptionManager.AddConsolidator(_spy, consolidator);
        // Add a consolidator handler to check that the breakout condition is fulfilled and traded.
        consolidator.DataConsolidated += OnConsolidated;

        SetWarmUp(TimeSpan.FromDays(1));
    }

    private void OnConsolidated(object sender, TradeBar bar)
    {
        _windows.Add(bar);

        if (_windows.IsReady)
        {
            // Buy if the breakout price action is fulfilled.
            // 1. Increasing price trend.
            // 2. The last 3 bars are green.
            // 3. The 3rd and 2nd last bars range is decreasing.
            // 4. The last bar exceeds the 2nd last bar by double the 2nd last bar's range.
            var secondLastRange = _windows[1].Close - _windows[1].Open;
            if (bar.Close > _windows[1].Close && _windows[1].Close > _windows[2].Close &&
            _windows[2].Close > _windows[2].Open && _windows[1].Close > _windows[1].Open && _windows[0].Close > _windows[0].Open &&
            _windows[2].Close - _windows[2].Open > secondLastRange && bar.Close > _windows[1].Close + 2 * secondLastRange)
            {
                SetHoldings(_spy, 0.5m);
            }
        }
    }

    public override void OnOrderEvent(OrderEvent orderEvent)
    {
        if (orderEvent.Status == OrderStatus.Filled)
        {
            if (orderEvent.Ticket.OrderType == OrderType.Market)
            {
                // Stop loss order at 1%.
                var stopPrice = orderEvent.FillQuantity > 0m ? orderEvent.FillPrice * 0.99m : orderEvent.FillPrice * 1.01m;
                StopMarketOrder(_spy, -Portfolio[_spy].Quantity, stopPrice);
                // Take profit order at 2%.
                var takeProfitPrice = orderEvent.FillQuantity > 0m ? orderEvent.FillPrice * 1.02m : orderEvent.FillPrice * 0.98m;
                LimitOrder(_spy, -Portfolio[_spy].Quantity, takeProfitPrice);
            }
            else if (orderEvent.Ticket.OrderType == OrderType.StopMarket || orderEvent.Ticket.OrderType == OrderType.Limit)
            {
                // Cancel any open order if stop loss or take profit order filled.
                Transactions.CancelOpenOrders();
            }
        }
    }
}

class ConsolidatorHistoryAlgorithm(QCAlgorithm):
    # To hold 3 consolidated trade bars to identify a breakout pattern.
    windows = RollingWindow[TradeBar](3)

    def initialize(self) -> None:
        self.set_start_date(2021, 10, 1)
        self.set_end_date(2022, 1, 1)
        
        # Request SPY data for signal generation and trading.
        self.spy = self.add_equity("SPY", Resolution.MINUTE).symbol

        # The breakout is based on a 5-minute consolidated trade bar.
        consolidator = TradeBarConsolidator(timedelta(minutes=5))
        # Subscribe for automatically updating the consolidator with SPY data.
        self.subscription_manager.add_consolidator(self.spy, consolidator)
        # Add a consolidator handler to check that the breakout condition is fulfilled and traded.
        consolidator.data_consolidated += self.on_consolidated

        self.set_warm_up(timedelta(15))

    def on_consolidated(self, sender: object, bar: TradeBar) -> None:
        self.windows.add(bar)

        if self.windows.is_ready:
            # Buy if the breakout price action is fulfilled.
            # 1. Increasing price trend.
            # 2. The last 3 bars are green.
            # 3. The 3rd and 2nd last bars range is decreasing.
            # 4. The last bar exceeds the 2nd last bar by double the 2nd last bar's range.
            second_last_range = self.windows[1].close - self.windows[1].open
            if bar.close > self.windows[1].close and self.windows[1].close > self.windows[2].close and\
            self.windows[2].close > self.windows[2].open and self.windows[1].close > self.windows[1].open and\
            self.windows[0].close > self.windows[0].open and self.windows[2].close - self.windows[2].open > second_last_range and\
            bar.close > self.windows[1].close + 2 * second_last_range:
                self.set_holdings(self.spy, 0.5)

    def on_order_event(self, order_event: OrderEvent) -> None:
        if order_event.status == OrderStatus.FILLED:
            if order_event.ticket.order_type == OrderType.MARKET:
                # Stop loss order at 1%.
                stop_price = order_event.fill_price * 0.99 if order_event.fill_quantity > 0 else order_event.fill_price * 1.01
                self.stop_market_order(self.spy, -self.portfolio[self.spy].quantity, stop_price)
                # Take profit order at 2%.
                take_profit_price = order_event.fill_price * 1.02 if order_event.fill_quantity > 0 else order_event.fill_price * 0.98
                self.limit_order(self.spy, -self.portfolio[self.spy].quantity, take_profit_price)
            elif order_event.ticket.order_type == OrderType.STOP_MARKET or order_event.ticket.order_type == OrderType.LIMIT:
                # Cancel any open order if stop loss or take profit order filled.
                self.transactions.cancel_open_orders()