Updating Watchlist

from AlgorithmImports import *

class ScheduledUniverseGapTradingAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        # 1. Set requested backtest timeframe that includes 5/27 (SBET) and 6/6 (KNW)
        self.set_start_date(2021, 5, 20)
        self.set_end_date(2021, 6, 10)
        self.set_cash(100000)

        # Use second-resolution data to check price conditions every second in OnData
        self.universe_settings.resolution = Resolution.SECOND
        # Enable extended market hours to gather premarket volume data
        self.universe_settings.extended_market_hours = True

        # We'll store all coarse/fine-available US Equities in this dictionary daily
        # { Symbol: { 'premarketVol': float, 'prevClose': float, 'openPrice': float, 'entryPrice': float, 'inPosition': bool } }
        self._available_symbols = {}

        # We'll maintain a daily watchlist of symbols that pass criteria
        self._daily_watchlist = set()

        # Add coarse + fine selection to gather US equities fundamentals
        self.add_universe(self.coarse_selection_filter, self.fine_selection_filter)

        # Schedule the first scan at 9:30:05 local time
        self.schedule.on(
            self.date_rules.every_day(),
            self.time_rules.at(9, 30, 5),
            self.first_scan
        )

        # Then schedule repeated scans every 5 minutes from 09:35 to 15:55
        for hour in range(9, 16):
            for minute in range(0, 60, 5):
                # skip times before 9:35
                if hour == 9 and minute < 35:
                    continue
                # skip times after 15:55
                if hour == 15 and minute > 55:
                    continue
                if hour > 15:
                    continue

                self.schedule.on(
                    self.date_rules.every_day(),
                    self.time_rules.at(hour, minute),
                    self.re_scan
                )

        # A few seconds before close, schedule an exit event
        self.schedule.on(
            self.date_rules.every_day(),
            self.time_rules.before_market_close("SPY", 5),
            self.before_close
        )

        # We'll run second-resolution OnData checks
        self.set_security_initializer(lambda s: s.set_data_normalization_mode(DataNormalizationMode.RAW))
        self.set_brokerage_model(BrokerageName.DEFAULT)

    def coarse_selection_filter(self, coarse: List[CoarseFundamental]) -> List[Symbol]:
        # Keep only if Price >= 0.20, HasFundamentalData, and US equity
        results = []
        for c in coarse:
            if c.has_fundamental_data and c.price >= 0.20:
                # Check if this is a US equity
                if c.symbol.id.market.lower() == "usa":
                    results.append(c.symbol)
        return results

    def fine_selection_filter(self, fine: List[FineFundamental]) -> List[Symbol]:
        # Keep only if f.Exchange is among recognized NYSE/NASDAQ tiers.
        # Note: Using f.Exchange because some environments may not have f.primary_exchange available.
        valid_exchanges = {
            "NYSE", "AMEX", "ARCA", "NAS", "NMS", "BATS",
            "NYSE MKT", "NYSE ARCA", "NASDAQ", "NASDAQ GS", "NASDAQ GM",
            "NYSE American", "NYSE National", "NYSE Chicago"
        }
        selected = []
        for f in fine:
            if f.Exchange in valid_exchanges:
                selected.append(f.symbol)
        return selected

    def on_securities_changed(self, changes: SecurityChanges) -> None:
        # Track newly added symbols
        for sec in changes.added_securities:
            sym = sec.symbol
            if sym not in self._available_symbols:
                self._available_symbols[sym] = {
                    'premarketVol': 0.0,
                    'prevClose': 0.0,
                    'openPrice': 0.0,
                    'entryPrice': 0.0,
                    'inPosition': False
                }

        # Remove no-longer-present symbols
        for sec in changes.removed_securities:
            sym = sec.symbol
            if sym in self._available_symbols:
                self._available_symbols.pop(sym, None)

    def on_data(self, data: Slice) -> None:
        # 4. Check watchlist every second.
        to_remove = []
        for sym in list(self._daily_watchlist):
            if sym not in self._available_symbols:
                # If the symbol is no longer available, remove it
                to_remove.append(sym)
                continue

            info = self._available_symbols[sym]
            security = self.securities[sym]
            if not security.has_data:
                # If we lack price data at this second, skip
                continue

            price = security.price
            if price <= 0 or info['openPrice'] <= 0:
                # Invalid or missing open price
                continue

            if not info['inPosition']:
                # If price >= openPrice * 1.30, buy
                if price >= info['openPrice'] * 1.30:
                    qty = self.calculate_order_quantity(sym, 0.1)
                    if qty != 0:
                        self.market_order(sym, qty)
                        info['entryPrice'] = price
                        info['inPosition'] = True
            else:
                # If in position, sell if price >= entry * 1.35 or price <= entry * 0.65
                if price >= info['entryPrice'] * 1.35 or price <= info['entryPrice'] * 0.65:
                    holdings = self.portfolio[sym]
                    if holdings.quantity > 0:
                        self.market_order(sym, -holdings.quantity)
                    info['inPosition'] = False
                    info['entryPrice'] = 0.0

                    # Remove from watchlist so we won't re-trade it
                    to_remove.append(sym)

        for sym in to_remove:
            if sym in self._daily_watchlist:
                self._daily_watchlist.remove(sym)

    def first_scan(self) -> None:
        # 2. First scan @ 9:30:05
        # Filter by open >= 0.25, premarket volume >= 1M, rank by gap desc, top 10
        self._daily_watchlist.clear()

        if len(self._available_symbols) == 0:
            self.debug(f"[{self.time}] No symbols in coarse/fine.")
            return

        start = self.time.replace(hour=4, minute=0, second=0, microsecond=0)
        end = self.time.replace(hour=9, minute=30, second=0, microsecond=0)
        candidates = []

        for sym, info in self._available_symbols.items():
            # Get previous close from daily bars
            hist_daily = self.history(
                sym, 
                2, 
                Resolution.DAILY, 
                fill_forward=False, 
                extended_market_hours=False
            )

            prev_close = 0.0
            if not hist_daily.empty:
                df_daily = hist_daily.loc[sym]
                if isinstance(df_daily, pd.DataFrame):
                    for row in df_daily.itertuples():
                        # row.Index might be (sym, timestamp) in multiindex
                        bar_time = row.Index[1] if isinstance(row.Index, tuple) else row.Index
                        if bar_time.date() < self.time.date():
                            prev_close = row.close

            if prev_close <= 0:
                continue

            info['prevClose'] = prev_close

            # Official open price: try to retrieve the 9:30 bar
            open_bar = self.history(
                sym,
                self.time.replace(hour=9, minute=30, second=0, microsecond=0),
                self.time.replace(hour=9, minute=30, second=0, microsecond=0),
                Resolution.MINUTE,
                fill_forward=False,
                extended_market_hours=True
            )

            official_open = 0.0
            if not open_bar.empty:
                df_930 = open_bar.loc[sym] if (sym in open_bar.index.get_level_values(0)) else None
                if df_930 is not None:
                    if isinstance(df_930, pd.DataFrame):
                        ts_930 = self.time.replace(hour=9, minute=30, second=0, microsecond=0)
                        if (sym, ts_930) in df_930.index:
                            official_open = df_930.loc[(sym, ts_930)].open
                    elif isinstance(df_930, pd.Series):
                        official_open = df_930.open

            if official_open <= 0 and sym in self.securities:
                official_open = self.securities[sym].open

            info['openPrice'] = official_open
            if official_open < 0.25:
                continue

            # Gather premarket volume from 04:00 to 09:30
            pre_history = self.history(
                sym, 
                start, 
                end, 
                Resolution.MINUTE, 
                fill_forward=False, 
                extended_market_hours=True
            )

            total_vol = 0.0
            if not pre_history.empty:
                df_pre = pre_history.loc[sym] if (sym in pre_history.index.get_level_values(0)) else None
                if df_pre is not None and isinstance(df_pre, pd.DataFrame):
                    total_vol = df_pre.volume.sum()

            info['premarketVol'] = total_vol

            if total_vol < 1_000_000:
                continue

            gap = (official_open - prev_close) / prev_close if prev_close > 0 else -99999
            candidates.append((sym, gap))

        # Sort descending by gap, pick top 10
        candidates.sort(key=lambda x: x[1], reverse=True)
        top_syms = [s for s, _ in candidates[:10]]

        for s in top_syms:
            self._daily_watchlist.add(s)
            self.ensure_symbol_data(s)

        self.debug(f"[{self.time}] First scan watchlist: {', '.join(str(x) for x in top_syms)}")

    def re_scan(self) -> None:
        # 3. Every 5 minutes from 09:35 to 15:55
        # Filter: price >= 0.25, intraday volume >= 1M, rank by current gap descending, top 10
        if len(self._available_symbols) == 0:
            return

        now_t = self.time
        open_t = now_t.replace(hour=9, minute=30, second=0, microsecond=0)
        candidates = []

        for sym, info in self._available_symbols.items():
            if info['prevClose'] <= 0:
                continue
            if sym not in self.securities:
                continue

            security = self.securities[sym]
            if not security.has_data:
                continue

            current_price = security.price
            if current_price < 0.25:
                continue

            # Gather intraday volume from 09:30 to now
            hist = self.history(
                sym,
                open_t,
                now_t,
                Resolution.MINUTE,
                fill_forward=False,
                extended_market_hours=True
            )

            total_vol = 0.0
            if not hist.empty:
                df_hist = hist.loc[sym] if (sym in hist.index.get_level_values(0)) else None
                if df_hist is not None and isinstance(df_hist, pd.DataFrame):
                    total_vol = df_hist.volume.sum()

            if total_vol < 1_000_000:
                continue

            # gap = (current_price - prev_close) / prev_close
            gap = (current_price - info['prevClose']) / info['prevClose']
            candidates.append((sym, gap))

        # Sort descending by gap, pick top 10
        candidates.sort(key=lambda x: x[1], reverse=True)
        top_syms = [s for s, _ in candidates[:10]]
        top_set = set(top_syms)

        for s in top_set:
            self.ensure_symbol_data(s)

        self.debug(f"[{self.time}] ReScan watchlist: {', '.join(str(x) for x in top_set)}")

        # Remove old watchers not in top_set and not in position
        to_remove = []
        for sym in self._daily_watchlist:
            if sym not in top_set:
                if not self._available_symbols[sym]['inPosition']:
                    to_remove.append(sym)

        for r in to_remove:
            self._daily_watchlist.remove(r)

        # Add any new top 10 symbols if not in watchlist and not in position
        for s in top_set:
            if s not in self._daily_watchlist:
                if not self._available_symbols[s]['inPosition']:
                    self._daily_watchlist.add(s)

    def before_close(self) -> None:
        # 5. Liquidate everything, log, clear watchlist
        self.debug(f"[{self.time}] Before close: Liquidating all positions.")
        self.liquidate()
        self._daily_watchlist.clear()

    def ensure_symbol_data(self, symbol: Symbol) -> None:
        # Ensure we have a second-resolution subscription
        if not self.securities.contains_key(symbol):
            self.add_equity(symbol.value, Resolution.SECOND, extended_market_hours=True)

This algorithm does the full strategy you described, including logging the watchlist for each scan and day, and handles exchanges, premarket/intraday filtering, price triggers, repeat purchases prevention, and daily resets. To ensure SBET (5/27) and KNW (6/6) appear in the watchlist as needed, set the backtest range as shown above and run the backtest on QuantConnect.

Sources: Head & Shoulders TA Pattern Detection, Empty Equity And Options400 Benchmark, Momentum Effect In Commodities Futures, WallStreetBets - QuantConnect.com, Momentum Short Term Reversal Strategy