Gap Ups

from AlgorithmImports import *
from typing import Dict, Set
class GapUpMomentumAlgorithm(QCAlgorithm):
    """
    Intraday gap-up momentum strategy.

    Rules
    1.   09:31 ET → pick the 20 biggest positive gap-ups (Open vs. prev-close)
         inside the 1 000 most liquid US equities (price >$1).
    2.   Monitor those symbols every second.
    3.   Enter long when price ≥ 30 % above today’s open, then
         immediately submit a 35 % profit-target AND 35 % stop-loss (OCO).
    4.   After any exit, never trade that symbol again the same day.
    5.   One minute before the close → liquidate everything and reset state.
    """

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

        # --- strategy constants
        self._max_watchlist       = 20     # symbols to follow intraday
        self._gap_trigger         = 0.30   # +30 % above open → buy
        self._exit_pct            = 0.35   # ±35 % stop / target
        self._capital_per_trade   = 0.05   # 5 % of available cash

        # --- daily-reset containers
        self._prev_close   : Dict[Symbol, float] = {}
        self._open_prices  : Dict[Symbol, float] = {}
        self._watchlist    : Set[Symbol]         = set()
        self._traded_today : Set[Symbol]         = set()
        self._entry_tickets: Dict[Symbol, OrderTicket] = {}
        self._stop_tickets : Dict[Symbol, OrderTicket] = {}
        self._limit_tickets: Dict[Symbol, OrderTicket] = {}
        self._gap_computed = False

        # --- universe  (minute resolution → light weight)
        self.universe_settings.resolution = Resolution.MINUTE
        self.add_universe(self._coarse_selection)

        # benchmark symbol – needed only for scheduling
        self.add_equity("SPY", Resolution.MINUTE)

        # --- schedules
        self.schedule.on(self.date_rules.every_day("SPY"),
                         self.time_rules.after_market_open("SPY", 1),
                         self._build_gap_watchlist)          # 09:31
        self.schedule.on(self.date_rules.every_day("SPY"),
                         self.time_rules.before_market_close("SPY", 1),
                         self._end_of_day)                   # 15:59

    # -----------------------------------------------------  UNIVERSE  --
    def _coarse_selection(self, coarse):
        """Keep the 1 000 most liquid stocks (price >$1) and save prev-close."""
        liquid   = [c for c in coarse if c.price > 1]
        top_1000 = sorted(liquid, key=lambda c: c.dollar_volume, reverse=True)[:1000]

        self._prev_close = {c.symbol: c.price for c in top_1000}

        # daily reset of intraday state
        self._open_prices.clear()
        self._watchlist.clear()
        self._traded_today.clear()
        self._entry_tickets.clear()
        self._stop_tickets.clear()
        self._limit_tickets.clear()
        self._gap_computed = False

        return [c.symbol for c in top_1000]

    # ---------------------------------------------  09:31 – GAP SCAN  --
    def _build_gap_watchlist(self) -> None:
        if self._gap_computed or not self._prev_close:
            return

        symbols = list(self._prev_close.keys())
        history = self.history(symbols, 1, Resolution.MINUTE)     # first minute bar
        if history.empty:
            return

        candidates = []   # (symbol, gap %, open)
        for symbol in symbols:
            if symbol not in history.index.get_level_values(0):
                continue
            bar        = history.loc[symbol].iloc[0]
            open_price = float(bar["open"])
            prev_close = self._prev_close.get(symbol, 0.0)
            if prev_close <= 0:
                continue
            gap = (open_price - prev_close) / prev_close
            if gap > 0:
                candidates.append((symbol, gap, open_price))

        top = sorted(candidates, key=lambda x: x[1], reverse=True)[:self._max_watchlist]
        for symbol, gap, open_price in top:
            self._watchlist.add(symbol)
            self._open_prices[symbol] = open_price
            self.add_equity(symbol.value, Resolution.SECOND)       # second-level feed

        self._gap_computed = True
        if self._watchlist:
            self.debug(f"{self.time:%Y-%m-%d}  GAP list → {[s.value for s in self._watchlist]}")

    # ----------------------------------------------------  ONDATA  --
    def on_data(self, data: Slice) -> None:
        if not self._watchlist:
            return

        for symbol in list(self._watchlist):          # copy – can shrink while looping
            if symbol in self._traded_today or symbol in self._entry_tickets:
                continue
            if not data.contains_key(symbol):
                continue

            price      = data[symbol].price
            open_price = self._open_prices.get(symbol, 0.0)
            if open_price <= 0:
                continue

            # entry condition
            if price >= open_price * (1 + self._gap_trigger):
                cash = self.portfolio.cash * self._capital_per_trade
                if price <= 0 or cash < price:
                    continue
                qty = max(1, int(cash / price))

                ticket = self.market_order(symbol, qty, tag="Entry")
                self._entry_tickets[symbol] = ticket
                self._traded_today.add(symbol)        # block duplicate entries

    # ----------------------------------------------  ORDER EVENTS  --
    def on_order_event(self, e: OrderEvent) -> None:
        if e.status != OrderStatus.FILLED:
            return

        symbol = e.symbol
        order  = self.transactions.get_order_by_id(e.order_id)

        # 1) entry filled  →  submit OCO bracket
        if order.tag == "Entry":
            entry_price = e.fill_price
            qty         = e.fill_quantity                # positive
            stop_price  = round(entry_price * (1 - self._exit_pct), 2)
            limit_price = round(entry_price * (1 + self._exit_pct), 2)

            stop  = self.stop_market_order(symbol, -qty, stop_price,  tag="StopLoss")
            limit = self.limit_order(symbol,       -qty, limit_price, tag="ProfitTarget")

            self._stop_tickets[symbol]  = stop
            self._limit_tickets[symbol] = limit

        # 2) exit leg filled  →  cancel sibling & purge symbol
        elif order.tag in {"StopLoss", "ProfitTarget"}:
            sibling = (self._limit_tickets.get(symbol) if order.tag == "StopLoss"
                       else self._stop_tickets.get(symbol))
            if sibling and sibling.status not in {OrderStatus.FILLED, OrderStatus.CANCELED}:
                sibling.cancel("OCO sibling filled")

            self._purge_symbol(symbol)

    # --------------------------------------------  HOUSE-KEEPING  --
    def _purge_symbol(self, symbol: Symbol) -> None:
        """Remove symbol from all intraday tracking structures."""
        self._watchlist.discard(symbol)
        self._entry_tickets.pop(symbol, None)
        self._stop_tickets.pop(symbol, None)
        self._limit_tickets.pop(symbol, None)
        self._traded_today.add(symbol)

    # --------------------------------------  END-OF-DAY RESET  --
    def _end_of_day(self) -> None:
        self.liquidate()
        self._open_prices.clear()
        self._watchlist.clear()
        self._entry_tickets.clear()
        self._stop_tickets.clear()
        self._limit_tickets.clear()
        self._traded_today.clear()
        self._gap_computed = False

This algorithm constructs a gap-up watchlist at the market open, monitors each symbol every second for the specified breakout condition, sets OCO stop/target, and ensures symbols are not re-traded after an exit that day. Everything resets before the close. Adjust the parameters as needed for your preferences and risk.

Sources: Momentum And State Of Market Filters, Gap Side By Side White - QuantConnect.com, Opening Range Breakout for Stocks in Play, Overnight Anomaly, True Beats - QuantConnect.com