Specific Debug

from datetime import date
from AlgorithmImports import *

class MorningGapScanner(QCAlgorithm):
    def initialize(self) -> None:
        # 1. Basic setup
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100000)
        self.set_time_zone(TimeZones.NEW_YORK)

        # Use daily data for universe selection
        self.universe_settings.resolution = Resolution.DAILY
        self.add_universe_selection(
            CoarseFundamentalUniverseSelectionModel(self.coarse_selection_function)
        )

        # Dictionaries and sets to store per-day information
        self._previous_close: Dict[Symbol, float] = {}
        self._today_open: Dict[Symbol, float] = {}
        self._traded_today: Set[Symbol] = set()
        self._watchlist: List[Symbol] = []

        # Schedule events to manage the daily process:
        # 1) Pick watchlist a few seconds after market open
        self.schedule.on(
            self.date_rules.every_day("SPY"),
            self.time_rules.at(9, 30, 10),
            self.pick_daily_watchlist
        )
        # 2) Liquidate a minute before market close
        self.schedule.on(
            self.date_rules.every_day("SPY"),
            self.time_rules.before_market_close("SPY", 1),
            self.end_of_day_liquidation
        )

    def coarse_selection_function(self, coarse: List[CoarseFundamental]) -> List[Symbol]:
        # Store the last close from coarse data and return all symbols
        new_symbols = []
        for c in coarse:
            self._previous_close[c.symbol] = c.price
            new_symbols.append(c.symbol)
        return new_symbols

    def pick_daily_watchlist(self) -> None:
        # Clear out the previous day's lists
        self._watchlist.clear()
        self._traded_today.clear()
        self._today_open.clear()

        gap_candidates: List[Tuple[Symbol, float, float]] = []
        current_time = self.time.date()

        # Build gap candidates list
        for symbol, y_close in self._previous_close.items():
            if symbol not in self.securities:
                continue

            sec = self.securities[symbol]
            if not sec.has_data:
                continue

            open_price = sec.price
            if open_price <= 0:
                continue

            if open_price >= 0.50 and y_close > 0:
                gap_up_percent = (open_price - y_close) / y_close
                gap_candidates.append((symbol, open_price, gap_up_percent))

        # Sort and pick top 100
        gap_candidates.sort(key=lambda x: x[2], reverse=True)
        top_100 = gap_candidates[:100]

        # Populate watchlist
        for sym, open_px, _ in top_100:
            self._today_open[sym] = open_px
            self._watchlist.append(sym)
            # Subscribe to second resolution data
            self.add_equity(sym.value, Resolution.SECOND)

        # Debug statements for specific dates/symbols
        # 5/27/2024 => SBET
        if current_time == date(2024, 5, 27):
            included = any(s.value == "SBET" for s in self._watchlist)
            if included:
                self.debug("[DEBUG 2024-05-27] SBET is included in today's watchlist.")
            else:
                self.debug("[DEBUG 2024-05-27] SBET is NOT included in today's watchlist.")

        # 6/6/2024 => KNW
        if current_time == date(2024, 6, 6):
            included = any(s.value == "KNW" for s in self._watchlist)
            if included:
                self.debug("[DEBUG 2024-06-06] KNW is included in today's watchlist.")
            else:
                self.debug("[DEBUG 2024-06-06] KNW is NOT included in today's watchlist.")

    def on_data(self, data: Slice) -> None:
        # Check each second for watchlisted stocks
        if not self._watchlist:
            return

        for symbol in list(self._watchlist):
            sec = self.securities[symbol]

            # Attempt entry if not invested
            if not sec.invested:
                if symbol not in self._traded_today and symbol in data.bars:
                    current_price = data.bars[symbol].close
                    open_price = self._today_open.get(symbol, 0)
                    if open_price > 0 and current_price >= 1.3 * open_price:
                        qty = self.calculate_order_quantity(symbol, 0.01)
                        if qty != 0:
                            self.market_order(symbol, qty)
                            self._traded_today.add(symbol)
            else:
                # If invested, check +35% or -35% gain/loss
                inv = sec.holdings
                entry_price = inv.average_price if inv.average_price > 0 else 0
                if entry_price == 0:
                    continue

                current_price = sec.price
                pnl_pct = (current_price - entry_price) / entry_price
                if pnl_pct >= 0.35 or pnl_pct <= -0.35:
                    self.liquidate(symbol)
                    if symbol in self._watchlist:
                        self._watchlist.remove(symbol)
                    self._traded_today.add(symbol)

    def end_of_day_liquidation(self) -> None:
        # Liquidate any remaining positions and clear the watchlist
        self.liquidate()
        self._watchlist.clear()
        self._traded_today.clear()
        self._today_open.clear()

This code creates a fresh daily watchlist, scans it every second, trades on your criteria, and logs only the required debug messages for SBET and KNW on the stated dates.

Sources: Scheduled Queuing Algorithm, docs writing algorithms datasets quiver quantitative wallstreetbets, Custom Data Universe Algorithm, docs writing algorithms datasets morningstar us fundamental data, Gap Side By Side White - QuantConnect.com

Thanks!