Debug More

from AlgorithmImports import *

class DailyGapTradingAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100000)
        self.universe_settings.resolution = Resolution.SECOND

        self._active_watchlist = []
        self._inclusion_reasons = {}
        self._entry_prices = {}
        self._positions = set()
        self._open_orders = {}
        self._prev_closes = {}
        self._today_opens = {}
        self._market_open_time = None
        self._schedule_events_set = False

        self.add_equity('SPY', Resolution.MINUTE)

        # BOTH selectors in single FineFundamentalUniverseSelectionModel
        self.add_universe_selection(
            FineFundamentalUniverseSelectionModel(self.coarse_selection_function, self.fine_selection_function)
        )

    def coarse_selection_function(self, coarse):
        # Only filter for universe, buy conditions are at open
        symbols = [x.symbol for x in coarse if x.has_fundamental_data and x.price > 0.5]
        return symbols[:3000]

    def fine_selection_function(self, fine):
        symbols = [x.symbol for x in fine if x.security_reference.is_primary_share and x.price > 0.5]
        return symbols[:500]

    def on_securities_changed(self, changes: SecurityChanges) -> None:
        for added in changes.added_securities:
            self._prev_closes[added.symbol] = 0.0
        for removed in changes.removed_securities:
            if removed.symbol in self._prev_closes:
                del self._prev_closes[removed.symbol]

    def on_data(self, data: Slice) -> None:
        if not self._schedule_events_set and self.time.hour >= 9:
            self._schedule_events_set = True
            self._market_open_time = self.securities['SPY'].Exchange.hours.get_next_market_open(self.time, False)
            open_time = self._market_open_time + timedelta(seconds=10)
            close_time = self.securities['SPY'].Exchange.hours.get_next_market_close(self.time, False) - timedelta(seconds=15)
            self.schedule.on(self.date_rules.every_day('SPY'), self.time_rules.at(open_time.hour, open_time.minute, open_time.second), self.create_watchlist)
            self.schedule.on(self.date_rules.every_day('SPY'), self.time_rules.at(close_time.hour, close_time.minute, close_time.second), self.pre_close_liquidate)
            # Every second event, after watchlist, remainder of day
            for sec in range(11, 23400, 1):
                self.schedule.on(self.date_rules.every_day('SPY'), self.time_rules.after_market_open('SPY', sec), self.secondly_checks)

    def create_watchlist(self) -> None:
        self._active_watchlist = []
        self._inclusion_reasons = {}
        self._today_opens = {}
        self._prev_closes = {}

        for symbol, security in self.securities.items():
            # Only consider new symbols, not SPY
            if not security.has_data or not security.is_tradable or symbol.value in ['SPY']:
                self._inclusion_reasons[symbol] = 'Not tradable or no data'
                continue
            try:
                history = self.history(symbol, 2, Resolution.DAILY)
            except Exception:
                self._inclusion_reasons[symbol] = 'History fetch error'
                continue
            if history.empty or len(history) < 2:
                self._inclusion_reasons[symbol] = 'No sufficient history'
                continue 
            prev_close = history['close'].iloc[-2] if 'close' in history.columns else None
            today_open = history['open'].iloc[-1] if 'open' in history.columns else None
            if prev_close is None or today_open is None or prev_close <= 0.0:
                self._inclusion_reasons[symbol] = 'Missing price data'
                continue
            self._prev_closes[symbol] = float(prev_close)
            self._today_opens[symbol] = float(today_open)
            if today_open >= 0.5 and today_open >= 1.1 * prev_close:
                self._active_watchlist.append(symbol)
                self._inclusion_reasons[symbol] = 'Open >= $0.50 AND open >= 1.10*prev_close'
            else:
                self._inclusion_reasons[symbol] = 'Did not meet gap criteria'

        # Special SBET 5/27 & KNW 6/6 logging
        date = self.time.date()
        sbet = Symbol.create('SBET', SecurityType.EQUITY, Market.USA)
        knw = Symbol.create('KNW', SecurityType.EQUITY, Market.USA)
        if date == datetime(2021, 5, 27).date():
            self.debug(f"SBET inclusion/exclusion: {self._inclusion_reasons.get(sbet, 'not found')}")
        if date == datetime(2021, 6, 6).date():
            self.debug(f"KNW inclusion/exclusion: {self._inclusion_reasons.get(knw, 'not found')}")
        self.debug(f"Today's watchlist: {[s.value for s in self._active_watchlist]}")
        for symbol, reason in self._inclusion_reasons.items():
            self.debug(f"{symbol.value}: {reason}")

    def secondly_checks(self) -> None:
        for symbol in list(self._active_watchlist):
            if symbol not in self.securities or not self.securities[symbol].is_tradable:
                continue
            security = self.securities[symbol]
            curr_price = security.price
            # Already in a position?
            if symbol in self._positions:
                entry = self._entry_prices.get(symbol, 0.0)
                if entry == 0.0:
                    continue
                # Take profit
                if curr_price >= entry * 1.35:
                    self.market_order(symbol, -self.portfolio[symbol].quantity)
                    self.debug(f"Exit (TP) {symbol.value} at {curr_price}, entry was {entry}")
                    self._active_watchlist.remove(symbol)
                    self._positions.remove(symbol)
                    continue
                # Stop loss
                if curr_price <= entry * 0.65:
                    self.market_order(symbol, -self.portfolio[symbol].quantity)
                    self.debug(f"Exit (SL) {symbol.value} at {curr_price}, entry was {entry}")
                    self._active_watchlist.remove(symbol)
                    self._positions.remove(symbol)
                continue
            # Only trade once per day
            if symbol in self._entry_prices:
                continue
            open_price = self._today_opens.get(symbol, 0.0)
            if open_price == 0.0:
                continue
            # Entry trigger
            if curr_price >= open_price * 1.3 and not self.portfolio[symbol].invested:
                qty = self.calculate_order_quantity(symbol, 0.03)
                try:
                    ticket = self.market_order(symbol, qty)
                    if ticket.status in [OrderStatus.FILLED, OrderStatus.SUBMITTED]:
                        self._entry_prices[symbol] = curr_price
                        self._positions.add(symbol)
                        self.debug(f"BUY {symbol.value} at {curr_price}")
                except Exception as e:
                    self.debug(f"Order failed for {symbol.value}: {str(e)}")

    def pre_close_liquidate(self) -> None:
        for symbol in list(self._positions):
            position = self.portfolio[symbol]
            if position.quantity != 0:
                self.liquidate(symbol)
                self.debug(f"Liquidating before close: {symbol.value}")
        self._positions.clear()
        self._active_watchlist.clear()
        self._entry_prices.clear()
        self.debug("Watchlist, positions, entries cleared for EOD.")

    def on_order_event(self, orderEvent: OrderEvent) -> None:
        if orderEvent.status == OrderStatus.FILLED:
            self.debug(f"OrderEvent: {orderEvent.symbol.value} {orderEvent.direction} {orderEvent.fill_price}")

This algorithm fully implements your requirements, including watchlist building, logging for SBET/KNW, real-time entry/exit, and daily reset. Let me know if you need any changes!

Sources: Basic Template Index Daily Algorithm, Head & Shoulders TA Pattern Detection, Overnight Anomaly, Momentum Effect In Commodities Futures, docs writing algorithms datasets quiver quantitative wallstreetbets

Thanks!