Universe Selection

public override void Initialize()
{
    // Run asynchronous universe selection to speed up your algorithm. 
    // In this case, you can't rely on the method or algorithm state between filter calls. 
    UniverseSettings.Asynchronous = true;
    AddUniverseSelection(new FundamentalUniverseSelectionModel(FundamentalFilterFunction));
}

public override List<Symbol> FundamentalFilterFunction(List<Fundamental> fundamental)
{
    return (from f in fundamental
            // Select symbols with fundamental data and a price above $10.
            where f.Price > 10 && !Double.IsNaN(f.ValuationRatios.PERatio)
            // Sort the assets in ascending order by their P/E ratio.
            orderby f.ValuationRatios.PERatio
            // Select the first 10 assets.
            select f.Symbol).Take(10);
}

def initialize(self) -> None:
    # Run asynchronous universe selection to speed up your algorithm. 
    # In this case, you can't rely on the method or algorithm state between filter calls. 
    self.universe_settings.asynchronous = True
    self.add_universe_selection(FundamentalUniverseSelectionModel(self._fundamental_filter_function))

def _fundamental_filter_function(self, fundamental: List[Fundamental]):
    # Select symbols with fundamental data and a price above $10.
    filtered = [f for f in fundamental if f.price > 10 and not np.isnan(f.valuation_ratios.pe_ratio)]
    # Sort the assets in ascending order by their P/E ratio.
    sorted_by_pe_ratio = sorted(filtered, key=lambda f: f.valuation_ratios.pe_ratio)
    # Select the first 10 assets.
    return [f.symbol for f in sorted_by_pe_ratio[:10]]

// In the Initialize method, enable asynchronous universe selection to speed up your algorithm.
UniverseSettings.Asynchronous = true;
// Add a custom universe selection model that selects undervalued, liquid stocks.
AddUniverseSelection(new LiquidAndLowPEUniverseSelectionModel());

// Outside of the algorithm class, define the universe selection model.
public class LiquidAndLowPEUniverseSelectionModel : FundamentalUniverseSelectionModel
{
    public override IEnumerable Select(QCAlgorithm algorithm, IEnumerable fundamental)
    {
        return fundamental
            // Select symbols with fundamental data and a price above $1.
            .Where(x => x.HasFundamentalData && x.Price > 1 && !Double.IsNaN(x.ValuationRatios.PERatio))
            // Select the 100 assets with the greatest daily dollar volume.
            .OrderByDescending(x => x.DollarVolume)
            .Take(100)
            // Select the 10 assets with the lowest PE ratio.
            .OrderByDescending(x => x.ValuationRatios.PERatio)
            .Take(10)
            .Select(x => x.Symbol);
    }
}

# In the initialize method, enable asynchronous universe selection to speed up your algorithm.
self.universe_settings.asynchronous = True
# Add a custom universe selection model that selects undervalued, liquid stocks.
self.add_universe_selection(LiquidAndLowPEUniverseSelectionModel())

# Outside of the algorithm class, define the universe selection model.
class LiquidAndLowPEUniverseSelectionModel(FundamentalUniverseSelectionModel):
    def select(self, fundamental: List[Fundamental]) -> List[Symbol]:
        # Select symbols with fundamental data and a price above $1.
        filtered = [x for x in fundamental if x.price > 1 and not np.isnan(x.valuation_ratios.pe_ratio)]
        # Select the 100 assets with the greatest daily dollar volume.
        most_liquid = sorted(filtered, key=lambda x: x.dollar_volume, reverse=True)[:100]
        # Select the 10 assets with the lowest PE ratio.
        lowest_pe_ratio = sorted(most_liquid, key=lambda x: x.valuation_ratios.pe_ratio, reverse=True)[:10]
        return [x.Symbol for x in lowest_pe_ratio]

// Initialize asynchronous universe settings for faster processing and add EmaCrossUniverseSelectionModel to dynamically manage the universe based on EMA cross signals to identify trending assets.
public override void Initialize()
{
    UniverseSettings.Asynchronous = true;        
    AddUniverseSelection(new EmaCrossUniverseSelectionModel());
}

# Initialize asynchronous universe settings for faster processing and add EmaCrossUniverseSelectionModel to dynamically manage the universe based on EMA cross signals to identify trending assets.
def initialize(self) -> None:
    self.universe_settings.asynchronous = True   
    self.add_universe_selection(EmaCrossUniverseSelectionModel())