Trade Plan

from AlgorithmImports import *
class TQQQFirstCandleStrategy(QCAlgorithm):
    """
    Intraday strategy for TQQQ:
    1) Inspect the first 5-minute bar of each trading day.
    2) Go long (green bar) or short (red bar) with 25 % equity
       at the open of the second 5-minute bar.
       Skip the day on a doji.
    3) Attach a 5 %-ATR stop-loss (ATR-14 daily).
    4) Close any open position 1-minute before the session ends.
    Only one trade per day is permitted.
    """

    # ---------------------------------------------------------------------- #
    # Initialization                                                         #
    # ---------------------------------------------------------------------- #
    def initialize(self) -> None:
        # Core settings
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100_000)

        # Asset subscription (minute data, RAW prices)
        equity = self.add_equity("TQQQ", Resolution.MINUTE)
        equity.set_data_normalization_mode(DataNormalizationMode.RAW)
        self._symbol: Symbol = equity.symbol

        # Daily ATR(14)
        self._atr = self.atr(self._symbol, 14, MovingAverageType.SIMPLE, Resolution.DAILY)
        self.set_warm_up(21, Resolution.DAILY)          # 14-day ATR + buffer

        # EOD liquidation event
        self.schedule.on(
            self.date_rules.every_day(self._symbol),
            self.time_rules.before_market_close(self._symbol, 1),
            self._eod_liquidate
        )

        # State trackers
        self._today: date = datetime.min.date()
        self._direction: int = 0                      # +1 long, –1 short, 0 none
        self._has_traded: bool = False
        self._stop_ticket: OrderTicket | None = None
        self._minute_buffer: list[TradeBar] = []      # Build 5-minute candles
        self._stop_mult: float = 0.05                 # 5 % of ATR

    # ---------------------------------------------------------------------- #
    # OnData – build 5-minute bars                                           #
    # ---------------------------------------------------------------------- #
    def on_data(self, data: Slice) -> None:           # noqa: N802  (QC naming)
        if self.is_warming_up or not data.contains_key(self._symbol):
            return

        self._minute_buffer.append(data[self._symbol])
        if len(self._minute_buffer) < 5:
            return                                   # need 5×1-min bars

        bar = self._combine(self._minute_buffer)
        self._minute_buffer.clear()
        self._process_five_bar(bar)

    # ---------------------------------------------------------------------- #
    # Combine five 1-minute bars into one 5-minute TradeBar                  #
    # ---------------------------------------------------------------------- #
    @staticmethod
    def _combine(bars: list[TradeBar]) -> TradeBar:
        fst, lst = bars[0], bars[-1]
        return TradeBar(
            fst.time, fst.symbol,
            fst.open,
            max(b.high for b in bars),
            min(b.low  for b in bars),
            lst.close,
            sum(b.volume for b in bars),
            timedelta(minutes=5)
        )

    # ---------------------------------------------------------------------- #
    # Main bar-processing logic                                              #
    # ---------------------------------------------------------------------- #
    def _process_five_bar(self, bar: TradeBar) -> None:
        session = bar.end_time.date()

        # New day -> reset flags & evaluate first bar
        if session != self._today:
            self._reset_day(session, bar)
            return

        # Already traded or skipped?
        if self._has_traded:
            return

        # This is the second 5-minute bar – place trade
        self._enter_trade(bar)

    # ---------------------------------------------------------------------- #
    # Reset day-specific state                                               #
    # ---------------------------------------------------------------------- #
    def _reset_day(self, session: date, bar: TradeBar) -> None:
        self._today, self._has_traded, self._direction = session, False, 0

        # Cancel old stop if still working
        if self._stop_ticket and self._stop_ticket.status in {OrderStatus.SUBMITTED, OrderStatus.PARTIALLY_FILLED}:
            self.cancel_order(self._stop_ticket.order_id)
        self._stop_ticket = None

        # First 5-minute bar sets direction
        if bar.close > bar.open:
            self._direction = 1
        elif bar.close < bar.open:
            self._direction = -1

    # ---------------------------------------------------------------------- #
    # Enter position at open of 2nd bar                                      #
    # ---------------------------------------------------------------------- #
    def _enter_trade(self, bar: TradeBar) -> None:
        if self._direction == 0 or not self._atr.is_ready:
            self._has_traded = True         # skip for doji / no ATR
            return

        price = bar.open
        cash_to_use = self.portfolio.total_portfolio_value * 0.25
        qty = int(cash_to_use / price)
        if qty == 0:
            return

        order_qty =  self._direction * qty
        self.market_order(self._symbol, order_qty, False, "Entry")

        # Stop-loss 5 % of ATR
        stop_dist = self._atr.current.value * self._stop_mult
        stop_price = price - stop_dist if self._direction == 1 else price + stop_dist
        self._stop_ticket = self.stop_market_order(self._symbol, -order_qty, stop_price)

        self.debug(f"{self.time}  Price: {price:.2f}  atr: {self._atr.current.value:.2f}  StopDist: {stop_dist:.2f}")
        self._has_traded = True

    # ---------------------------------------------------------------------- #
    # End-of-day liquidation                                                 #
    # ---------------------------------------------------------------------- #
    def _eod_liquidate(self) -> None:
        if self._stop_ticket and self._stop_ticket.status in {OrderStatus.SUBMITTED, OrderStatus.PARTIALLY_FILLED}:
            self.cancel_order(self._stop_ticket.order_id)
            self._stop_ticket = None

        if self.portfolio[self._symbol].invested:
            self.liquidate(self._symbol, "EOD Liquidation")

This code fulfills your requirements and logs ATR/price/stop values at entry for debugging purposes.

Sources: docs writing algorithms securities asset classes us equity handling data, docs writing algorithms trading and orders order management order tickets, docs writing algorithms securities asset classes us equity data preparation, Logging - QuantConnect.com, docs writing algorithms portfolio key concepts

Thanks!

Plan for TQQQ 5-Minute Candle StrategyObjective: Create an algorithm that trades TQQQ based on the first 5-minute candle of each day.Key Requirements:Use 25% of account for each positionLong if first 5-minute candle is green, short if redSkip if first candle is a doji (open = close)Set data normalization to RAWStop loss: 5% of 14-day ATRClose position before market close if stop loss not hitLog ATR and price values for debuggingImplementation Approach:Initialize TQQQ with 5-minute resolution and RAW data normalizationAdd ATR indicator with 14-day periodTrack daily state (first candle processed, position opened)Use scheduled events for market open and closeImplement position management with ATR-based stop lossfrom from AlgorithmImports import *
from datetime import timedelta

class TQQQFiveMinuteCandleStrategy(QCAlgorithm):
   """
   TQQQ 5-Minute Candle Strategy

   Each day:
   1. Check first 5-minute candle of the day
   2. If green (close > open): Open long position with 25% of account
   3. If red (close < open): Open short position with 25% of account
   4. If doji (close = open): Skip trading for the day
   5. Stop loss: 5% of 14-day Average True Range
   6. Close position before market close if stop loss not hit
   """

   def Initialize(self):
       # Set start and end dates for backtesting
       self.SetStartDate(2023, 1, 1)
       self.SetEndDate(2024, 1, 1)

       # Set initial cash
       self.SetCash(100000)

       # Add TQQQ with 5-minute resolution and RAW data normalization
       self.tqqq = self.AddEquity(
           "TQQQ",
           Resolution.Minute,
           dataNormalizationMode=DataNormalizationMode.Raw
       )

       # Add Average True Range indicator (14-day period)
       self.atr = self.ATR(self.tqqq.Symbol, 14, resolution=Resolution.Daily)

       # Set warm-up period for ATR indicator
       self.SetWarmUp(20, Resolution.Daily)

       # Initialize tracking variables
       self.daily_state = {
           'first_candle_processed': False,
           'position_opened': False,
           'entry_price': 0,
           'stop_loss_price': 0,
           'position_direction': 0,  # 1 for long, -1 for short
           'atr_value': 0
       }

       # Schedule daily reset at market open
       self.Schedule.On(
           self.DateRules.EveryDay("TQQQ"),
           self.TimeRules.AfterMarketOpen("TQQQ", 0),
           self.DailyReset
       )

       # Schedule position close before market close
       self.Schedule.On(
           self.DateRules.EveryDay("TQQQ"),
           self.TimeRules.BeforeMarketClose("TQQQ", 5),  # 5 min before close
           self.ClosePositionBeforeClose
       )

       # Debug logging
       self.Debug("TQQQ 5-Minute Candle Strategy Initialized")
       self.Debug(f"Data Normalization Mode: {self.tqqq.DataNormalizationMode}")

   def OnData(self, data):
       """Handle incoming data"""
       # Skip if warming up
       if self.IsWarmingUp:
           return

       # Skip if ATR not ready
       if not self.atr.IsReady:
           return

       # Process first candle if not done yet
       if (not self.daily_state['first_candle_processed'] and
               data.ContainsKey(self.tqqq.Symbol)):
           self.ProcessFirstCandle(data[self.tqqq.Symbol])

       # Check stop loss if position is open
       if (self.daily_state['position_opened'] and
               data.ContainsKey(self.tqqq.Symbol)):
           self.CheckStopLoss(data[self.tqqq.Symbol])

   def ProcessFirstCandle(self, bar):
       """Process the first 5-minute candle of the day"""
       # Check if this is the first 5-minute candle (9:30-9:35 AM ET)
       current_time = self.Time
       market_open = current_time.replace(hour=9, minute=30, second=0,
                                          microsecond=0)
       first_candle_end = market_open + timedelta(minutes=5)

       if current_time < market_open or current_time >= first_candle_end:
           return

       # Mark first candle as processed
       self.daily_state['first_candle_processed'] = True

       # Get OHLC data
       open_price = bar.Open
       close_price = bar.Close

       # Check for doji (open price = close price)
       if abs(open_price - close_price) < 0.01:  # Small tolerance
           self.Debug(f"[{self.Time}] First candle is DOJI - Skipping trade "
                      f"today. Open: {open_price}, Close: {close_price}")
           return

       # Determine position direction
       if close_price > open_price:
           # Green candle - Long position
           self.daily_state['position_direction'] = 1
           self.Debug(f"[{self.Time}] First candle is GREEN - "
                      f"Preparing LONG position")
       else:
           # Red candle - Short position
           self.daily_state['position_direction'] = -1
           self.Debug(f"[{self.Time}] First candle is RED - "
                      f"Preparing SHORT position")

       # Store ATR value for debugging
       self.daily_state['atr_value'] = self.atr.Current.Value

       # Log debug information
       self.Debug(f"[{self.Time}] ATR (14-day): "
                  f"{self.daily_state['atr_value']:.4f}")
       self.Debug(f"[{self.Time}] Open: {open_price:.2f}, "
                  f"Close: {close_price:.2f}")

       # Schedule position opening at second candle open (9:35 AM)
       self.Schedule.On(
           self.DateRules.Today,
           self.TimeRules.At(9, 35),
           self.OpenPosition
       )

   def OpenPosition(self):
       """Open position at second candle open"""
       if self.daily_state['position_opened']:
           return

       # Get current price (second candle open)
       current_price = self.Securities[self.tqqq.Symbol].Price

       if current_price == 0:
           self.Debug(f"[{self.Time}] No valid price for position opening")
           return

       # Calculate stop loss price
       atr_value = self.daily_state['atr_value']
       stop_loss_atr = atr_value * 0.05  # 5% of ATR

       if self.daily_state['position_direction'] == 1:
           # Long position
           stop_loss_price = current_price - stop_loss_atr
           self.Debug(f"[{self.Time}] Opening LONG position at "
                      f"{current_price:.2f}")
           self.Debug(f"[{self.Time}] Stop loss set at "
                      f"{stop_loss_price:.2f} (ATR: {atr_value:.4f}, "
                      f"5% ATR: {stop_loss_atr:.4f})")
       else:
           # Short position
           stop_loss_price = current_price + stop_loss_atr
           self.Debug(f"[{self.Time}] Opening SHORT position at "
                      f"{current_price:.2f}")
           self.Debug(f"[{self.Time}] Stop loss set at "
                      f"{stop_loss_price:.2f} (ATR: {atr_value:.4f}, "
                      f"5% ATR: {stop_loss_atr:.4f})")

       # Store position details
       self.daily_state['entry_price'] = current_price
       self.daily_state['stop_loss_price'] = stop_loss_price
       self.daily_state['position_opened'] = True

       # Open position
       self.SetHoldings(self.tqqq.Symbol,
                        0.25 * self.daily_state['position_direction'])

   def OnOrderEvent(self, orderEvent):
       """Handle order events"""
       if orderEvent.Status == OrderStatus.Filled:
           self.Debug(f"[{self.Time}] Order filled: {orderEvent}")

   def CheckStopLoss(self, bar):
       """Check if stop loss should be triggered"""
       current_price = bar.Close

       if self.daily_state['position_direction'] == 1:
           # Long position - check if price hit stop loss
           if current_price <= self.daily_state['stop_loss_price']:
               self.Debug(f"[{self.Time}] STOP LOSS HIT for LONG position. "
                          f"Current: {current_price:.2f}, "
                          f"Stop: {self.daily_state['stop_loss_price']:.2f}")
               self.Liquidate(self.tqqq.Symbol)
               self.daily_state['position_opened'] = False
       else:
           # Short position - check if price hit stop loss
           if current_price >= self.daily_state['stop_loss_price']:
               self.Debug(f"[{self.Time}] STOP LOSS HIT for SHORT position. "
                          f"Current: {current_price:.2f}, "
                          f"Stop: {self.daily_state['stop_loss_price']:.2f}")
               self.Liquidate(self.tqqq.Symbol)
               self.daily_state['position_opened'] = False

   def ClosePositionBeforeClose(self):
       """Close position before market close"""
       if self.daily_state['position_opened']:
           current_price = self.Securities[self.tqqq.Symbol].Price
           self.Debug(f"[{self.Time}] Closing position before market close "
                      f"at {current_price:.2f}")
           self.Liquidate(self.tqqq.Symbol)
           self.daily_state['position_opened'] = False

   def DailyReset(self):
       """Reset daily state at market open"""
       self.daily_state = {
           'first_candle_processed': False,
           'position_opened': False,
           'entry_price': 0,
           'stop_loss_price': 0,
           'position_direction': 0,
           'atr_value': 0
       }
       self.Debug(f"[{self.Time}] Daily reset completed")