Intraday buy points

from AlgorithmImports import *

class MyUniverseAlgo(QCAlgorithm):
    def initialize(self) -> None:
        # 1. Set the requested start/end dates and initial cash
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100000)

        # Add SPY so we can reference its market times in scheduling
        self.add_equity("SPY", Resolution.MINUTE)

        # Dictionaries and lists to track daily data
        self._day_open: Dict[Symbol, float] = {}
        self._day_watchlist: List[Symbol] = []
        self._purchased_symbols: Set[Symbol] = set()
        self._entry_prices: Dict[Symbol, float] = {}

        # 2. Universe selection settings
        self.universe_settings.resolution = Resolution.MINUTE
        self.set_security_initializer(lambda s: s.set_data_normalization_mode(DataNormalizationMode.ADJUSTED))
        self.add_universe(self.coarse_selection_function, self.fine_selection_function)

        # 3. Schedule a handler to build a daily watchlist 1 minute after market open
        self.schedule.on(
            self.date_rules.every_day(),
            self.time_rules.after_market_open("SPY", 1),
            self.build_daily_watchlist
        )

        # 4. Schedule a handler to liquidate positions 10 seconds before market close
        self.schedule.on(
            self.date_rules.every_day(),
            self.time_rules.before_market_close("SPY", 10),
            self.liquidate_positions
        )

        # 5. Schedule a handler to reset (clear) the watchlist after market close
        self.schedule.on(
            self.date_rules.every_day(),
            self.time_rules.at(16, 10),
            self.reset_daily_watchlist
        )

    def coarse_selection_function(self, coarse: List[CoarseFundamental]) -> List[Symbol]:
        # Include up to 1000 highest DollarVolume symbols that have fundamental data
        filtered = [c for c in coarse if c.has_fundamental_data and c.price > 0 and c.volume > 100000]
        filtered.sort(key=lambda x: x.dollar_volume, reverse=True)
        return [c.symbol for c in filtered[:1000]]

    def fine_selection_function(self, fine: List[FineFundamental]) -> List[Symbol]:
        # Filter to NYSE or NASDAQ, and pick top 500 by MarketCap
        filtered = []
        for f in fine:
            if f.company_reference is not None and f.company_reference.primary_exchange_id in ["NYS", "NAS"]:
                filtered.append(f)
        filtered.sort(key=lambda x: x.market_cap, reverse=True)
        return [f.symbol for f in filtered[:500]]

    def on_data(self, data: Slice) -> None:
        """
        Repeatedly check:
         - If a watchlist symbol meets 50% above today's open for a buy
         - If its open position meets 30% take-profit or 30% stop-loss
        """
        for symbol in self._day_watchlist:
            if symbol not in data.bars:
                continue

            bar = data.bars[symbol]
            # Check if we have an open price for today
            if symbol not in self._day_open:
                continue

            day_open_price = self._day_open[symbol]
            current_price = bar.close

            # Check if we haven't purchased yet, and price >= 1.5 * today's open
            if symbol not in self._purchased_symbols:
                if day_open_price > 0 and current_price >= 1.5 * day_open_price:
                    self._purchased_symbols.add(symbol)
                    quantity = self.calculate_order_quantity(symbol, 0.01)
                    if quantity != 0:
                        self.market_order(symbol, quantity)
                        self._entry_prices[symbol] = current_price

            # For open positions, check 30% take-profit and 30% stop-loss
            if symbol in self._entry_prices:
                entry_price = self._entry_prices[symbol]
                take_profit = entry_price * 1.30
                stop_loss = entry_price * 0.70

                holdings = self.portfolio[symbol]
                if holdings.invested:
                    if current_price >= take_profit or current_price <= stop_loss:
                        self.liquidate(symbol, "Exit on TP/SL")

    def build_daily_watchlist(self) -> None:
        """
        After market open, gather today's open and previous day's close:
         - Add symbols to watchlist if today's open >= $3
           and >= 40% above yesterday's close
        """
        self._day_watchlist.clear()
        self._purchased_symbols.clear()
        self._day_open.clear()
        self._entry_prices.clear()

        # Loop through active equities
        for symbol in self.active_securities.keys:
            security = self.active_securities[symbol]
            if security.type != SecurityType.EQUITY:
                continue
            if not security.has_data:
                continue

            bar = security.get_last_data()
            if not isinstance(bar, TradeBar):
                continue

            today_open = bar.open

            # Get previous day close
            hist = self.history(symbol, 1, Resolution.DAILY)
            if not hist.empty:
                prior_close = float(hist.tail(1)["close"][0])
            else:
                prior_close = 0

            self._day_open[symbol] = today_open

            # Check open >= 3 and open >= 1.4 * prior close
            if today_open >= 3.0 and prior_close > 0:
                if today_open >= 1.4 * prior_close:
                    self._day_watchlist.append(symbol)

        self.debug(f"Daily Watchlist built with {len(self._day_watchlist)} symbols.")

        # Subscribe to second resolution if not already
        for sym in self._day_watchlist:
            if not self.securities.contains_key(sym):
                self.add_equity(sym.value, Resolution.SECOND)
            else:
                self.securities[sym].set_data_resolution(Resolution.SECOND)

    def liquidate_positions(self) -> None:
        """
        Liquidate all open positions about 10 seconds before market close
        """
        self.liquidate("Exiting all before close")

    def reset_daily_watchlist(self) -> None:
        """
        After market close (16:10), reset watchlist and references
        """
        self._day_watchlist.clear()
        self._purchased_symbols.clear()
        self._entry_prices.clear()
        self._day_open.clear()
        self.debug("Watchlist reset after market close.")

Explanation / Key points for 'S':

• Yes, QuantConnect lets you create a new stock watchlist every day based on market data (Step 2).
• You can scan a daily watchlist for price triggers every second (Step 3).
• The algo implements your entry and exit rules, and schedules liquidate/reset events, as requested.
• Scale and data capacity may be a practical consideration if your universe is very large, but this structure works for prototyping and even for many stocks in practice.
• All logic is in QCAlgorithm and supports a realistic backtest. If you want the universe or order sizing changed, let me know!

Sources: True Beats - QuantConnect.com, WallStreetBets - QuantConnect.com, Dropbox Base Data Universe Selection Algorithm, Custom Data Universe Algorithm, docs writing algorithms datasets quantconnect us etf constituents

Thanks so much!  Can you change the universe to scan all tiers of NYSE and all tiers of Nasdaq at market open every day?  It looks like what you wrote only looks at the top 500