Equity

public class MyUniverseAlgorithm : QCAlgorithm {
    private Universe _universe;
    public override void Initialize() 
    {
        UniverseSettings.Asynchronous = true;
        // Add a fundamental universe with a custom filter function.
        _universe = AddUniverse(FundamentalFilterFunction);
    }
        
    private IEnumerable<Symbol> FundamentalFilterFunction(IEnumerable<Fundamental> fundamental) 
    {   
         // Select US Equities that have fundamental data. 
         return (from f in fundamental
                where f.HasFundamentalData
                select f.Symbol);
    }
}

class MyUniverseAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.universe_settings.asynchronous = True
        # Add a fundamental universe with a custom filter function.
        self._universe = self.add_universe(self._fundamental_function)
    
    def _fundamental_function(self, fundamental: List[Fundamental]) -> List[Symbol]:
        # Select US Equities that have fundamental data. 
        return [c.symbol for c in fundamental if c.has_fundamental_data]

// Select the top 50 most liquid US Equities and then select the 10 with
// lowest PE ratios.
UniverseSettings.Asynchronous = true;
_universe = AddUniverse(
    fundamental => (from f in fundamental
        where f.Price > 10 && f.HasFundamentalData && !Double.IsNaN(f.ValuationRatios.PERatio)
        orderby f.DollarVolume descending
        select f).Take(100)
        .OrderBy(f => f.ValuationRatios.PERatio).Take(10)
        .Select(f => f.Symbol));

# In the initialize method:
self.universe_settings.asynchronous = True
# Add a fundamental universe with a custom filter function.
self._universe = self.add_universe(self._fundamental_selection_function)
    
def _fundamental_selection_function(self, fundamental: List[Fundamental]) -> List[Symbol]:
    # Select assets that have a price > $10, fundamental data, and a price_to_earnings ratio. 
    filtered = [f for f in fundamental if f.price > 10 and f.has_fundamental_data and not np.isnan(f.valuation_ratios.pe_ratio)]
    # Select the 100 most liquid assets.
    sorted_by_dollar_volume = sorted(filtered, key=lambda f: f.dollar_volume, reverse=True)[:100]
    # Select the 10 assets with the lowest P/E ratios. 
    sorted_by_pe_ratio = sorted(sorted_by_dollar_volume, key=lambda f: f.valuation_ratios.pe_ratio)[:10]
    # Return the selected securities.
    return [f.symbol for f in sorted_by_pe_ratio]

// Select the US Equities in the technology sector.
var tech = fundamental.Where(x => x.AssetClassification.MorningstarSectorCode == MorningstarSectorCode.Technology);

# Select the US Equities in the technology sector.
tech = [x for x in fundamental if x.asset_classification.morningstar_sector_code == MorningstarSectorCode.TECHNOLOGY]

// Select the US Equities in the agricluture industry group. 
var ag = fundamental.Where(x => x.AssetClassification.MorningstarIndustryGroupCode == MorningstarIndustryGroupCode.Agriculture);

# Select the US Equities in the agricluture industry group. 
ag = [x for x in fundamental if x.asset_classification.morningstar_industry_group_code == MorningstarIndustryGroupCode.AGRICULTURE]

// Select the US Equities in the coal industry.
var coal = fundamental.Where(x => x.AssetClassification.MorningstarIndustryCode == MorningstarIndustryCode.Coal);

# Select the US Equities in the coal industry.
coal = [x for x in fundamental if x.asset_classification.morningstar_industry_code == MorningstarIndustryCode.COAL]

private IEnumerable<Symbol> FundamentalFilterFunction(IEnumerable<Fundamental> fundamentals) 
{ 
    return fundamentals
        // Select objects that have a value for the fundamental property.
        .Where(f => f.HasFundamentalData && !Double.IsNaN(f.ValuationRatios.PERatio))
        // Sort the objects by the fundamental property.
        .OrderBy(f => f.ValuationRatios.PERatio)
        .Take(10)
        .Select(x => x.Symbol);
}

def _fundamental_selection_function(self, fundamental: List[Fundamental]) -> List[Symbol]:
    # Select objects that have a value for the fundamental property.
    filtered = [f for f in fundamental if f.has_fundamental_data and not np.isnan(f.valuation_ratios.pe_ratio)]
    # Sort the objects by the fundamental property.
    sorted_by_pe_ratio = sorted(filtered, key=lambda f: f.valuation_ratios.pe_ratio)
    return [f.symbol for f in sortedByPeRatio[:10] ]