Opening Range Break paper

from AlgorithmImports import *

class TqqqOrbAuditAlgorithm(QCAlgorithm):
    """
    Opening-Range-Breakout (ORB) diagnostic algorithm for TQQQ.

    The focus is NOT live profitability but code-quality.  The script logs and
    sanity-checks every rule that is often implemented incorrectly:

    1.  Wrong time window for the opening range
    2.  Breakouts evaluated/filled before 10:00
    3.  Multiple entries on the same day
    4.  Forgetting to flatten before the close
    5.  Running on anything other than minute data
    """

    def initialize(self) -> None:
        # ------------------------------------------------------------------ #
        #  Engine set-up                                                     #
        # ------------------------------------------------------------------ #
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100_000)

        # — Rule-5 check: force minute data —
        self._tqqq = self.add_equity("TQQQ", Resolution.MINUTE)
        if self._tqqq.resolution != Resolution.MINUTE:
            self.debug(f"ERROR: ORB must run on minute data, found "
                       f"{self._tqqq.resolution}")

        # Optional realism – constant fee/slippage models
        self._tqqq.set_fee_model(ConstantFeeModel(0))          # no commissions
        self._tqqq.set_slippage_model(ConstantSlippageModel(0.01))

        # ------------------------------------------------------------------ #
        #  Daily state (reset @ 09:30 each session)                          #
        # ------------------------------------------------------------------ #
        self._opening_range_high = 0.0
        self._opening_range_low = 0.0
        self._collecting_opening_range = False
        self._opening_range_finalised = False
        self._trade_entered_today = False

        # ------------------------------------------------------------------ #
        #  Scheduled events – ALL time-based logic lives here                #
        # ------------------------------------------------------------------ #
        # 09:30  – begin OR capture
        self.schedule.on(self.date_rules.every_day(self._tqqq.symbol),
                         self.time_rules.at(9, 30),
                         self._start_opening_range)

        # 10:00  – finish OR capture
        self.schedule.on(self.date_rules.every_day(self._tqqq.symbol),
                         self.time_rules.at(10, 0),
                         self._end_opening_range)

        # 15:59  – mandatory flatten
        self.schedule.on(self.date_rules.every_day(self._tqqq.symbol),
                         self.time_rules.at(15, 59),
                         self._close_positions_eod)

        # 16:01  – post-close audit (rule-4)
        self.schedule.on(self.date_rules.every_day(self._tqqq.symbol),
                         self.time_rules.at(16, 1),
                         self._verify_flat)

        self.debug("ORB diagnostics initialised.")

    # ---------------------------------------------------------------------- #
    #  Daily-life cycle helpers                                              #
    # ---------------------------------------------------------------------- #
    def _start_opening_range(self) -> None:
        """Reset flags and start building today's opening range."""
        self._opening_range_high = float("-inf")
        self._opening_range_low = float("inf")
        self._collecting_opening_range = True
        self._opening_range_finalised = False
        self._trade_entered_today = False
        self.debug(f"{self.time:%Y-%m-%d} 09:30 – opened OR capture.")

    def _end_opening_range(self) -> None:
        """Freeze ORH/ORL – trading is now allowed."""
        self._collecting_opening_range = False
        self._opening_range_finalised = True

        # Rule-1 diagnostic
        if (self._opening_range_high == float("-inf")
                or self._opening_range_low == float("inf")):
            self.debug("ERROR: Opening range empty – wrong collection window!")
        self.debug(f"OR finalised – High: {self._opening_range_high:.2f} | "
                   f"Low: {self._opening_range_low:.2f}")

    def _close_positions_eod(self) -> None:
        """Flatten before the close (fixes rule-4)."""
        if self.portfolio[self._tqqq.symbol].invested:
            self.liquidate(self._tqqq.symbol, "EOD flatten")
            self.debug("15:59 – liquidated for EOD risk.")
        # allow tomorrow's trade
        self._trade_entered_today = False

    def _verify_flat(self) -> None:
        """Audit that we're not holding overnight."""
        if self.portfolio[self._tqqq.symbol].invested:
            self.debug("ERROR: Overnight position detected – flatten failed!")
        else:
            self.debug("Post-close audit – portfolio flat as expected.")

    # ---------------------------------------------------------------------- #
    #  Main data handler                                                     #
    # ---------------------------------------------------------------------- #
    def on_data(self, data: Slice) -> None:
        if self.is_warming_up:
            return

        # --------------------- 09:30 ≤ t < 10:00 ---------------------------
        if self._collecting_opening_range and data.contains_key(self._tqqq.symbol):
            bar = data[self._tqqq.symbol]
            self._opening_range_high = max(self._opening_range_high, bar.high)
            self._opening_range_low = min(self._opening_range_low, bar.low)
            return                                 # nothing else before 10:00

        # --------------------- trading window ------------------------------
        # Prevent rules 2 & 3 violations
        if (not self._opening_range_finalised
                or self._trade_entered_today
                or not data.contains_key(self._tqqq.symbol)):
            return

        price = data[self._tqqq.symbol].close

        # Long breakout
        if price > self._opening_range_high:
            self.set_holdings(self._tqqq.symbol, 1.0)
            self._trade_entered_today = True
            self.debug(f"{self.time} LONG @ {price:.2f} > ORH "
                       f"{self._opening_range_high:.2f}")
            return

        # Short breakout
        if price < self._opening_range_low:
            self.set_holdings(self._tqqq.symbol, -1.0)
            self._trade_entered_today = True
            self.debug(f"{self.time} SHORT @ {price:.2f} < ORL "
                       f"{self._opening_range_low:.2f}")

How to use this:

• Compare your code's structure and logic to each block in the above diagnostic template.
• Check your opening range window, and signals, and ensure you are not re-entering or holding overnight.
• Run with the logging level set to DEBUG to view output with the OR range and trade triggers for every session.
• This should help surface exactly where your logic is diverging from the expected ORB rules in the SSRN paper and common QuantConnect pitfalls.

Sources: Opening Range Breakout for Stocks in Play, Data Preparation - QuantConnect.com, Consolidate Different Tick Types Regression Algorithm, docs writing algorithms live trading brokerages, docs writing algorithms trading and orders order errors