Gap Filtering

from AlgorithmImports import *
class MarketCapFilteredUniverseAlgorithm(QCAlgorithm):
    """
    Demonstrates the 4 suggested universe-selection improvements:

    1. Filter by a minimum market-capitalization ($5 B)
    2. Filter by a minimum dollar-volume ($10 M)
    3. Sort by market-cap to keep the top 50 stocks
    4. Rebalance the portfolio daily, liquidating symbols that leave the universe
    """

    # --------------------------- Constants ---------------------------------
    _min_market_cap = 5_000_000_000      # $5 B
    _min_dollar_vol = 10_000_000         # $10 M
    _max_symbols = 50                    # Top-N by market-cap

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

    def initialize(self) -> None:
        """Set up the algorithm parameters and universe."""
        # Backtest parameters
        self.set_start_date(2018, 1, 1)
        self.set_end_date(2020, 1, 1)
        self.set_cash(100_000)

        # Use daily data for all universe securities
        self.universe_settings.resolution = Resolution.DAILY

        # Internal state
        self._universe: set[Symbol] = set()           # Current universe symbols
        self._last_rebalance: datetime.date = datetime.min.date()

        # Add a coarse-fundamental universe selection function
        self.add_universe(self._coarse_selection)

    # ----------------------------------------------------------------------
    # Universe selection
    # ----------------------------------------------------------------------

    def _coarse_selection(self, coarse: list[CoarseFundamental]) -> list[Symbol]:
        """Coarse universe selection based on size & liquidity."""
        # Apply the size & liquidity filters
        filtered = [
            c for c in coarse
            if c.has_fundamental_data
            and c.dollar_volume is not None and c.dollar_volume > self._min_dollar_vol
            and c.market_cap is not None and c.market_cap > self._min_market_cap
        ]

        if not filtered:
            return []

        # Sort by descending market-cap and keep the top N
        sorted_by_cap = sorted(filtered, key=lambda x: x.market_cap, reverse=True)
        return [c.symbol for c in sorted_by_cap[: self._max_symbols]]

    # ----------------------------------------------------------------------
    # Event handlers
    # ----------------------------------------------------------------------

    def on_securities_changed(self, changes: SecurityChanges) -> None:
        """Track universe membership and liquidate removed symbols."""
        # Liquidate symbols that leave the universe
        for security in changes.removed_securities:
            symbol = security.symbol
            if self.portfolio[symbol].invested:
                self.liquidate(symbol, "Left universe")

        # Update the internal universe set
        removed = {s.symbol for s in changes.removed_securities}
        added = {s.symbol for s in changes.added_securities}
        self._universe.difference_update(removed)
        self._universe.update(added)

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

    def on_data(self, slice: Slice) -> None:
        """Rebalance once per day, holding equal weights in the universe."""
        today = self.time.date()

        # Do nothing if we already rebalanced today or the universe is empty
        if today == self._last_rebalance or len(self._universe) == 0:
            return

        self._last_rebalance = today

        # Equal-weight allocation, with division-by-zero protection
        count = len(self._universe)
        if count == 0:
            return
        weight = 1.0 / count

        # Set holdings for every symbol in the universe
        for symbol in self._universe:
            if symbol in self.securities and self.securities[symbol].is_tradable:
                self.set_holdings(symbol, weight)

This code incorporates all four universe and rebalance recommendations from the forum link you mentioned.

Sources: Key Concepts - QuantConnect.com, Fundamental Universes - QuantConnect.com, Coarse Fundamental Top3 Algorithm, US Fundamental Data - QuantConnect.com, Coarse Fine Fundamental Combo Algorithm