Gap Filters

Here is the corrected version of your algorithm, implementing all four requested changes:

from AlgorithmImports import *
class IntradayGapUpUniverseAlgorithm(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2025, 5, 23)
        self.set_end_date(2025, 6, 9)
        self.set_cash(100_000)
        self.add_equity("SPY", Resolution.MINUTE)
        self.set_benchmark("SPY")

        self._daily_candidates = {}
        self._watchlist = set()
        self._open_prices = {}
        self._entered = set()
        self._oco = {}
        self._stake = 5_000.0

        self.universe_settings.resolution = Resolution.MINUTE
        self.add_universe(self._coarse_select)

        # 1. Build the gap universe every day at 09:31
        self.schedule.on(
            self.date_rules.every_day(),
            self.time_rules.at(9, 31),
            self._build_gap_universe,
        )

        self.schedule.on(
            self.date_rules.every_day("SPY"),
            self.time_rules.before_market_close("SPY", 5),
            self._end_of_day,
        )

        self.set_security_initializer(
            lambda s: s.set_data_normalization_mode(DataNormalizationMode.RAW)
        )

    # ----------------------------------------------------------------------
    # Universe selection helpers
    # ----------------------------------------------------------------------
    def _coarse_select(self, coarse):
        # Clear dictionary at midnight UTC (00:00 algorithm time)
        if self.time.hour == 0 and self.time.minute == 0:
            self._daily_candidates.clear()

        # 2. Price filter ONLY (>= $0.5)
        selected = [c for c in coarse if c.price >= 0.5]
        for c in selected:
            self._daily_candidates[c.symbol] = c
        return [c.symbol for c in selected]

    # ----------------------------------------------------------------------
    # Build gap-up universe at 09:31
    # ----------------------------------------------------------------------
    def _build_gap_universe(self):
        self._cleanup_dynamic()
        gap_list = []

        start_time = datetime.strptime("00:00", "%H:%M").time()
        open_time = datetime.strptime("09:30", "%H:%M").time()

        for symbol in list(self._daily_candidates.keys()):
            sec = self.securities.get(symbol)
            if not sec or not sec.has_data:
                continue

            # 3. Minute history with extended hours to compute pre-market volume
            try:
                hist = self.history(
                    symbol,
                    571,                       # 00:00 → 09:30 inclusive
                    Resolution.MINUTE,
                    extended_market_hours=True,
                )
            except Exception:
                continue
            if hist.empty:
                continue

            times = hist.index.get_level_values(1).time
            hist = hist[(times >= start_time) & (times <= open_time)]

            pre_vol = hist["volume"].sum()
            if pre_vol < 1_000_000:
                continue

            # 4. Gap calculation
            open_row = hist.loc[times == open_time, "open"]
            if open_row.empty:
                continue
            today_open = float(open_row.values[0])

            daily_hist = self.history(symbol, 1, Resolution.DAILY)
            if daily_hist.empty:
                continue
            prev_close = float(daily_hist["close"].iloc[-1])
            if prev_close == 0:
                continue

            gap_pct = (today_open - prev_close) / prev_close
            gap_list.append((symbol, gap_pct))

        gap_list.sort(key=lambda x: x[1], reverse=True)
        top = gap_list[:50]
        chosen = {s for s, _ in top}

        # Debug helpers (existing business logic)
        self._log_symbol("SBET", datetime(2025, 5, 27), chosen)
        self._log_symbol("KNW", datetime(2025, 6, 6), chosen)

        for symbol, _ in top:
            eq = self.add_equity(
                symbol.value,
                Resolution.SECOND,
                extended_market_hours=True,
            )
            eq.set_data_normalization_mode(DataNormalizationMode.RAW)
            self._watchlist.add(symbol)
            self._open_prices[symbol] = float(eq.open)

        self.debug(f"{self.time}  watch-list created: {len(self._watchlist)} symbols")

    # ----------------------------------------------------------------------
    # Trading logic (unchanged)
    # ----------------------------------------------------------------------
    def on_data(self, data):
        if self.time < self.time.replace(hour=9, minute=30) or self.time >= self.time.replace(hour=16, minute=0):
            return

        for symbol in list(self._watchlist):
            bar = data.bars.get(symbol)
            if bar is None:
                continue

            if self._open_prices.get(symbol, 0) <= 0:
                self._open_prices[symbol] = float(bar.open)

            open_price = self._open_prices[symbol]
            if open_price <= 0:
                continue

            if symbol in self._entered or self.portfolio[symbol].invested:
                continue

            if bar.close >= open_price * 1.30:
                qty = int(self._stake // bar.close)
                if qty > 0:
                    self.market_order(symbol, qty)
                    self._entered.add(symbol)
                    self.debug(f"{self.time}  BUY {symbol} @ {bar.close:.2f}  (open {open_price:.2f})  qty {qty}")

    def on_order_event(self, oe):
        if oe.status != OrderStatus.FILLED:
            return

        symbol = oe.symbol
        if oe.direction == OrderDirection.BUY:
            entry_price = oe.fill_price
            qty = self.portfolio[symbol].quantity
            tp = self.limit_order(symbol, -qty, round(entry_price * 1.35, 4), "TP 35%")
            sl = self.stop_market_order(symbol, -qty, round(entry_price * 0.65, 4), "SL -35%")
            self._oco[symbol] = (tp, sl)
            return

        if oe.direction == OrderDirection.SELL and symbol in self._oco:
            tp, sl = self._oco.pop(symbol)
            peer = sl if oe.order_id == tp.order_id else tp
            if peer.status not in (OrderStatus.CANCELED, OrderStatus.FILLED):
                peer.cancel("OCO peer executed")
            self._watchlist.discard(symbol)
            self._entered.discard(symbol)
            self.debug(f"{self.time}  CLOSED {symbol} via {oe.order_id}")

    # ----------------------------------------------------------------------
    # House-keeping helpers (unchanged)
    # ----------------------------------------------------------------------
    def _end_of_day(self):
        if self.portfolio.invested:
            self.liquidate()
        self._cleanup_dynamic()
        self.debug(f"{self.time}  portfolio flattened EOD")

    def _cleanup_dynamic(self):
        for sym in list(self.securities.keys()):
            if sym.value != "SPY":
                self.remove_security(sym)
        self._watchlist.clear()
        self._open_prices.clear()
        self._entered.clear()
        self._oco.clear()

    def _log_symbol(self, ticker, target_date, selected_set):
        if self.time.date() != target_date.date():
            return
        if any(s.value.upper() == ticker for s in selected_set):
            self.debug(f"{self.time.date()} – {ticker} INCLUDED in universe")
        else:
            sym = Symbol.create(ticker, SecurityType.EQUITY, Market.USA)
            reason = "failed price/volume screen" if sym not in self._daily_candidates else "not in top-50 gap list"
            self.debug(f"{self.time.date()} – {ticker} NOT included: {reason}")

Summary of main changes:

• The gap universe is now scheduled for 9:31am.
• Coarse filter only checks if price is above $0.5, not for prior day volume.
• Premarket volume (00:00–09:30) is calculated for each candidate using minute history with extended market hours.
• Only symbols with at least 1,000,000 premarket volume are considered.
• Gap is computed as (9:30 open - prev close) / prev close and top 50 are selected for the watchlist.

Let me know if you want to further discuss or clarify any part of the code!

Sources: Opening Range Breakout for Stocks in Play, Momentum And State Of Market Filters, Asset Growth Effect, Momentum Effect In Commodities Futures, docs writing algorithms datasets quantconnect us etf constituents