Premarket Volume Filter

from AlgorithmImports import *
from datetime import datetime
class GapMomentumAlgorithm(QCAlgorithm):
    """
    Intraday gap-momentum strategy.

    1. 09:30:10 ET Scheduled universe selection using all US stocks (daily resolution).
        • gap%  = (today_open / yesterday_close – 1)  
        • open  ≥ $0.50  
        • pre-market volume (04:00-09:30) ≥ 1 000 000
        • keep top-50 symbols by gap%  ➜ daily watch-list
        • log detailed reasons ONLY for SBET (2021-05-27) & KNW (2021-06-06)
    2. Subscribe to second-resolution data for the 50 symbols.
    3. Every second  
        • if price ≥ open × 1.30  and not invested  → buy (equal weight)  
        • if price ≥ entry × 1.35 or ≤ entry × 0.65 → liquidate & ban for the day
    4. 15:59:55 ET Liquidate anything that is still open and reset lists.
    """

    # ----------------------------------------------------------------------

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

        # containers
        self._watchlist: list[Symbol] = []        # intraday tradable symbols (max 50)
        self._open_prices: dict[Symbol, float] = {}
        self._entry_prices: dict[Symbol, float] = {}
        self._removed_today: set[Symbol] = set()
        self._coarse_candidates: list[Symbol] = []

        # constants
        self._pre_vol  = 1_000_000           # shares
        self._open_min = 0.50                # $ minimum official open
        self._breakout = 1.30                # 30 % over open – buy trigger
        self._tp       = 1.35                # 35 % target
        self._sl       = 0.65                # 35 % stop
        self._max_list = 50

        # universe – coarse runs once/day; keep it light
        self.universe_settings.resolution = Resolution.DAILY
        self.add_universe(self._coarse_select)

        # 09:30:10 detailed gap scan & subscriptions
        self.schedule.on(
            self.date_rules.every_day(),
            self.time_rules.at(9, 30, 10),
            self._gap_selection,
        )

        # 15:59:55 daily shutdown
        self.schedule.on(
            self.date_rules.every_day(),
            self.time_rules.at(15, 59, 55),
            self._eod_liquidate,
        )

    # ----------------------------------------------------------------------
    # 1.  Lightweight first pass – run by QC in the very early morning
    # ----------------------------------------------------------------------
    def _coarse_select(self, coarse) -> list[Symbol]:
        if not coarse:
            return []

        tradable = [x for x in coarse if x.price >= self._open_min]
        tradable.sort(key=lambda c: c.dollar_volume, reverse=True)
        top_300 = tradable[:300]

        self._coarse_candidates = [c.symbol for c in top_300]
        return self._coarse_candidates

    # ----------------------------------------------------------------------
    # 2.  09:30:10 ET detailed gap calculation & universe build
    # ----------------------------------------------------------------------
    def _gap_selection(self) -> None:
        if not self._coarse_candidates:
            return

        today        = self.time.date()
        eastern_now  = self.time      # QC default tz = NY
        selected: list[tuple[Symbol, float]] = []

        for symbol in self._coarse_candidates:
            # make sure we have a security so History/Price work
            if not self.securities.contains_key(symbol):
                self.add_equity(
                    symbol.value,
                    Resolution.MINUTE,
                    market=symbol.id.market,
                    fill_data_forward=True,
                    leverage=1,
                    extended_market_hours=True,
                )

            # -------- yesterday close (2 daily bars) --------
            hist_daily = self.history(symbol, 2, Resolution.DAILY)
            if hist_daily.empty or len(hist_daily.index) < 2:
                continue
            y_close = hist_daily["close"].iloc[-2]
            if y_close <= 0:
                continue

            # -------- today's “official” open ≈ price @ 09:30:10 --------
            today_open = self.securities[symbol].price
            if today_open <= 0:
                continue
            open_ok = today_open >= self._open_min

            # -------- pre-market volume 04:00 – 09:30 --------
            pre_start = datetime(
                eastern_now.year, eastern_now.month, eastern_now.day,
                4, 0, 0, tzinfo=eastern_now.tzinfo
            )
            hist_minute = self.history(
                symbol,
                pre_start,
                eastern_now,
                Resolution.MINUTE,
                extended_market_hours=True,
            )
            pre_vol = int(hist_minute["volume"].sum()) if not hist_minute.empty else 0
            vol_ok = pre_vol >= self._pre_vol

            # -------- DEBUG only SBET & KNW on the specific dates --------
            ticker = symbol.value.upper()
            if (ticker == "SBET" and today == datetime(2021, 5, 27).date()) or \
               (ticker == "KNW"  and today == datetime(2021, 6, 6).date()):
                reasons = []
                reasons.append("Open ≥ 0.50" if open_ok else "Rejected: Open < 0.50")
                reasons.append("PremktVol ≥ 1 M" if vol_ok else "Rejected: PremktVol < 1 M")
                self.debug(f"{ticker} {today}: {'; '.join(reasons)}")

            # combined filters
            if not (open_ok and vol_ok):
                continue

            gap_pct = today_open / y_close - 1.0
            selected.append((symbol, gap_pct))

        # keep top-50 gappers
        selected.sort(key=lambda x: x[1], reverse=True)
        top_syms = [s for s, _ in selected[: self._max_list]]

        # reset daily state
        self._watchlist.clear()
        self._open_prices.clear()
        self._entry_prices.clear()
        self._removed_today.clear()

        # subscribe @ second resolution
        for sym in top_syms:
            if not self.securities.contains_key(sym):
                self.add_equity(
                    sym.value,
                    Resolution.SECOND,
                    market=sym.id.market,
                    fill_data_forward=True,
                    leverage=1,
                    extended_market_hours=True,
                )
            self._watchlist.append(sym)

    # ----------------------------------------------------------------------
    # 3.  Second-level data handler – trading logic & risk management
    # ----------------------------------------------------------------------
    def on_data(self, data: Slice) -> None:
        if not self._watchlist:
            return

        for sym in list(self._watchlist):        # copy → safe removal
            bar = data.bars.get(sym, None)
            if bar is None:
                continue
            price = bar.close
            if price <= 0:
                continue

            # record open on first tick after 09:30
            if sym not in self._open_prices:
                self._open_prices[sym] = price
            open_px = self._open_prices[sym]

            # -------- entry  (+30 %) --------
            if (not self.portfolio[sym].invested) and price >= open_px * self._breakout:
                weight = 1.0 / float(self._max_list)          # equal-weight
                qty = self.calculate_order_quantity(sym, weight)
                if qty != 0:
                    self.market_order(sym, qty)
                    self._entry_prices[sym] = price

            # -------- exits  (+35 %  or  –35 %) --------
            if self.portfolio[sym].invested and sym in self._entry_prices:
                entry = self._entry_prices[sym]
                if price >= entry * self._tp or price <= entry * self._sl:
                    self.liquidate(sym, "TP/SL hit – no re-entry today")
                    self._removed_today.add(sym)

        # ban symbols we already exited
        for s in list(self._removed_today):
            if s in self._watchlist:
                self._watchlist.remove(s)

    # ----------------------------------------------------------------------
    # 4.  15:59:55 ET – flatten & daily reset
    # ----------------------------------------------------------------------
    def _eod_liquidate(self) -> None:
        self.liquidate()
        self._watchlist.clear()
        self._open_prices.clear()
        self._entry_prices.clear()
        self._removed_today.clear()

This code matches your requested behavior: universe selection 10 seconds after open with filters, precise logging for SBET and KNW, per-second scanning and trading, profit/stop loss exits, immediate re-entry ban, full flatten/reset at day end, and daily watchlist recreation.

Sources: Momentum And State Of Market Filters, Intraday ETF Momentum, Momentum Short Term Reversal Strategy, True Beats - QuantConnect.com, docs writing algorithms datasets quiver quantitative wallstreetbets

Thanks!