New Coarse Filter

Here’s code that implements your requested strategy in QuantConnect:

from AlgorithmImports import *

class GapScannerAlgorithm(QCAlgorithm):
    """
    Pre-market gap scanner / momentum strategy.

    Daily workflow
    1. 09:31 ET
       • From the 1 000 most liquid US-stocks (yesterday $-volume) measure
         pre-market dollar volume (00:00 → 09:30 ET).
       • Keep the 500 symbols with the largest pre-market dollar volume.
       • Compute the regular-session open gap vs. yesterday’s close.
       • Build a “morning watch-list’’ with the 20 highest positive gappers.
    2. During the session (second resolution)
       • Buy any watch-list stock that rallies ≥ 30 % above its opening price.
       • Sell any open position that reaches ± 35 % from its entry.
    3. 15:59:50 ET – liquidate everything.
    4. 16:01 ET – reset all daily state variables.
    """

    # --------------------------------------------------------
    # INITIALISATION
    # --------------------------------------------------------
    def initialize(self) -> None:
        # Back-test dates & capital
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(1_000_000)

        # Anchor symbol (added first so it exists for scheduling rules)
        self.add_equity("SPY", Resolution.MINUTE)

        # Universe settings and coarse universe selection
        self.universe_settings.resolution = Resolution.MINUTE
        self.add_universe(self._coarse_selection)

        # ---------- Internal state ----------
        self._watchlist: set[Symbol] = set()
        self._pre_market_candidates: list[Symbol] = []
        self._open_prices: dict[Symbol, float] = {}
        self._entry_prices: dict[Symbol, float] = {}
        self._target_weight: float = 0.05          # 5 % of equity per trade

        # ---------- Scheduled events ----------
        # 1 min after the open – gap / pre-market volume selection
        self.schedule.on(
            self.date_rules.every_day("SPY"),
            self.time_rules.after_market_open("SPY", 1),
            self._morning_selection,
        )

        # 10 s before the close – flatten everything
        self.schedule.on(
            self.date_rules.every_day("SPY"),
            self.time_rules.before_market_close("SPY", 10),
            self._preclose_liquidate,
        )

        # 1 min after the close – reset for next day
        self.schedule.on(
            self.date_rules.every_day("SPY"),
            self.time_rules.after_market_close("SPY", 1),
            self._reset_daily_state,
        )

    # --------------------------------------------------------
    # 1) COARSE UNIVERSE  (runs at midnight)
    # --------------------------------------------------------
    def _coarse_selection(
        self, coarse: List[CoarseFundamental]
    ) -> List[Symbol]:
        if self.is_warming_up:
            return []

        # Keep the 1 000 symbols with the highest dollar volume yesterday
        sorted_by_dv = sorted(
            coarse, key=lambda c: c.volume * c.price, reverse=True
        )
        self._pre_market_candidates = [c.symbol for c in sorted_by_dv[:1_000]]
        return self._pre_market_candidates

    # --------------------------------------------------------
    # 2) 09:31 ET – BUILD THE MORNING WATCH-LIST
    # --------------------------------------------------------
    def _morning_selection(self) -> None:
        if not self._pre_market_candidates:
            self.debug("[Selection] No coarse candidates.")
            return

        today = self.time.date()
        pm_start = datetime.combine(today, time(0, 0))
        pm_end   = datetime.combine(today, time(9, 30))

        # ----- PRE-MARKET DOLLAR-VOLUME ------------------------------------
        dv: dict[Symbol, float] = {}
        for symbol in self._pre_market_candidates:
            try:
                hist = self.history(
                    symbol,
                    pm_start,
                    pm_end,
                    Resolution.MINUTE,
                    extended_market_hours=True,
                )
                if hist.empty:
                    continue
                dv[symbol] = float((hist["close"] * hist["volume"]).sum())
            except Exception as e:
                self.error(f"History error {symbol}: {e}")

        if not dv:
            self.debug("[Selection] No pre-market data.")
            return

        top_500 = [
            s for s, _ in sorted(
                dv.items(), key=lambda kv: kv[1], reverse=True
            )[:500]
        ]

        # ----- GAP-UP CALCULATION ------------------------------------------
        gap_data: list[tuple[Symbol, float]] = []
        for symbol in top_500:
            # Ensure minute subscription so Securities[symbol].open is populated
            self.add_equity(symbol.value, Resolution.MINUTE, extended_market_hours=True)

            open_price = float(self.securities[symbol].open)
            if open_price <= 0:
                continue

            y_close_hist = self.history(
                symbol, 1, Resolution.DAILY, extended_market_hours=False
            )
            if y_close_hist.empty:
                continue
            y_close = float(y_close_hist.iloc[-1].close)
            if y_close == 0:
                continue

            gap = (open_price - y_close) / y_close
            if gap > 0:
                gap_data.append((symbol, gap))
                self._open_prices[symbol] = open_price

        gap_data.sort(key=lambda kv: kv[1], reverse=True)
        self._watchlist = set(sym for sym, _ in gap_data[:20])

        # Subscribe second-resolution data for trade scanning
        for sym in self._watchlist:
            self.add_equity(sym.value, Resolution.SECOND, fill_forward=True)

        self.debug(f"[Selection] Watch-list has {len(self._watchlist)} symbols.")

    # --------------------------------------------------------
    # 3) ONDATA  – runs every second
    # --------------------------------------------------------
    def on_data(self, data: Slice) -> None:
        # ---------- ENTRY ----------------------------------------------------
        for symbol in list(self._watchlist):
            if self.portfolio[symbol].invested:
                continue
            if not data.contains_key(symbol):
                continue
            price = self.securities[symbol].price
            if price == 0:
                continue

            open_price = self._open_prices.get(symbol, 0)
            if open_price == 0:
                continue

            if price >= open_price * 1.30:                       # +30 % rally
                qty = self.calculate_order_quantity(symbol, self._target_weight)
                if qty != 0:
                    self.market_order(symbol, qty)

        # ---------- EXIT (±35 %) --------------------------------------------
        for symbol in list(self.portfolio.keys()):
            holding = self.portfolio[symbol]
            if not holding.invested:
                continue

            entry = self._entry_prices.get(symbol, 0)
            if entry == 0:
                continue

            pnl = (holding.price - entry) / entry
            if pnl >= 0.35 or pnl <= -0.35:                       # +/-35 %
                self.liquidate(symbol, "±35 % threshold")
                self._watchlist.discard(symbol)

    # --------------------------------------------------------
    # ORDER EVENTS  – store fill prices
    # --------------------------------------------------------
    def on_order_event(self, orderEvent: OrderEvent) -> None:
        if orderEvent.status != OrderStatus.FILLED:
            return

        symbol = orderEvent.symbol
        if orderEvent.direction == OrderDirection.BUY:
            self._entry_prices[symbol] = orderEvent.fill_price
        elif orderEvent.direction == OrderDirection.SELL:
            self._entry_prices.pop(symbol, None)

    # --------------------------------------------------------
    # 4) PRE-CLOSE LIQUIDATION  (15:59:50 ET)
    # --------------------------------------------------------
    def _preclose_liquidate(self) -> None:
        if self.portfolio.invested:
            self.debug(f"[{self.time}] Pre-close liquidation.")
        self.liquidate()

    # --------------------------------------------------------
    # 5) DAILY RESET  (16:01 ET)
    # --------------------------------------------------------
    def _reset_daily_state(self) -> None:
        self.debug(f"[{self.time}] Resetting daily variables.")
        self._watchlist.clear()
        self._open_prices.clear()
        self._entry_prices.clear()
        self._pre_market_candidates.clear()

Key Features:

• Universe selection is performed 1 minute after market open, using pre-market dollar volume (midnight–9:30am).
• Top 20 gappers added to daily watchlist based on % gap-up from yesterday’s close to today’s open.
• Every second, looks for stocks rallying at least 30% above today’s open price—if so, buys them.
• Sells any open position at +35% or -35% from entry, and removes that stock from watchlist.
• Liquidates all positions 10 seconds before market close.
• Resets all internal state variables after close.

Let me know if you'd like further clarifications or adjustments!

Sources: True Beats - QuantConnect.com, Custom Data Universe Algorithm, Gap Side By Side White - QuantConnect.com, WallStreetBets - QuantConnect.com, Price Gap Mean Reversion Alpha