equity = self.add_equity("IBM")
ibm_fundamental = equity.fundamentals

var equity = AddEquity("IBM");
var ibmFundamental = equity.Fundamentals;

ibm = Symbol.create("IBM", SecurityType.EQUITY, Market.USA)
ibm_fundamental = self.fundamentals(ibm)

var ibm = QuantConnect.Symbol.Create("IBM", SecurityType.Equity, Market.USA);
var ibmFundamental = Fundamentals(ibm);

def initialize(self) -> None:
    self._universe = self.add_universe(self.fundamental_filter_function)

def fundamental_filter_function(self, fundamental: List[Fundamental]):
    filtered = [f for f in fundamental if f.has_fundamental_data and f.price > 10 and not np.isnan(f.valuation_ratios.pe_ratio)]
    sorted_by_pe_ratio = sorted(filtered, key=lambda f: f.valuation_ratios.pe_ratio)
    return [f.symbol for f in sorted_by_pe_ratio[:10]]

public override void Initialize()
{
    _universe = AddUniverseSelection(new FundamentalUniverseSelectionModel(FundamentalFilterFunction));
}

public override List<Symbol> FundamentalFilterFunction(List<Fundamental> fundamental)
{
    return (from f in fundamental
            where f.HasFundamentalData && f.Price > 10 && !Double.IsNaN(f.ValuationRatios.PERatio)
            orderby f.ValuationRatios.PERatio
            select f.Symbol).Take(10);
}

filteredFundamentals = fundamental.Where(x =>
    x.AssetClassification.MorningstarSectorCode == MorningstarSectorCode.Technology);

filtered_fundamentals = [x for x in fundamental
    if x.asset_classification.morningstar_sector_code == MorningstarSectorCode.TECHNOLOGY]

filteredFundamentals = fundamental.Where(x =>
    x.AssetClassification.MorningstarIndustryGroupCode == MorningstarIndustryGroupCode.ApplicationSoftware);

filtered_fundamentals = [x for x in fundamental
    if x.asset_classification.morningstar_industry_group_code == MorningstarIndustryGroupCode.APPLICATION_SOFTWARE]

filteredFundamentals = fundamental.Where(x =>
    x.AssetClassification.MorningstarIndustryCode == MorningstarIndustryCode.SoftwareApplication);

filtered_fundamentals = [x for x in fundamental
    if x.asset_classification.morningstar_industry_code == MorningstarIndustryCode.SOFTWARE_APPLICATION]

filteredFundamentals = fundamental.Where(x =>
    x.CompanyReference.PrimaryExchangeID == "NAS");

filtered_fundamentals = [x for x in fundamental
    if x.company_reference.primary_exchange_id == "NAS"]

class MorningStarDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2021, 7, 1)
        self.set_cash(100000) 
        self.universe_settings.asynchronous = True

        # Option 1: Subscribe to individual US Equity assets
        self.add_equity("IBM")        

        # Option 2A: Create a fundamental universe (classic version)
        self._universe = self.add_universe(self.fundamental_function)

        # Option 2B: Create a fundamental universe (framework version)
        self.add_universe_selection(FundamentalUniverseSelectionModel(self.fundamental_function))

namespace QuantConnect
{
    private Universe _universe;
    public class MorningStarDataAlgorithm : QCAlgorithm
    {    	
        public override void Initialize()
        {
            SetStartDate(2021, 1, 1);
            SetEndDate(2021, 7, 1);
            SetCash(100000);
            UniverseSettings.Asynchronous = true;
            
            // Option 1: Subscribe to individual US Equity assets
            AddEquity("IBM");

            // Option 2A: Create a fundamental universe (classic version)
            _universe = AddUniverse(FundamentalFilterFunction);

            // Option 2B: Create a fundamental universe (framework version)
            AddUniverseSelection(new FundamentalUniverseSelectionModel(FundamentalFilterFunction));
        }
    }
}

def fundamental_function(self, fundamental: List[Fundamental]) -> List[Symbol]:
    return [f.symbol for f in fundamental if f.price > 10 and f.valuation_ratios.pe_ratio > 30]

public IEnumerable<Symbol> FundamentalFunction(IEnumerable<Fundamental> fundamental)
{
    return fundamental.Where(f => f.Price > 10 && f.ValuationRatios.PERatios > 30).Select(f => f.Symbol);
}

fundamentals = self.securities[symbol].fundamentals

var fundamentals = Securities[symbol].Fundamentals;

// Single asset 
var ibm = QuantConnect.Symbol.Create("IBM", SecurityType.Equity, Market.USA);
var ibmFundamental = Fundamentals(ibm);

// Multiple assets
var nb = QuantConnect.Symbol.Create("NB", SecurityType.Equity, Market.USA);
var fundamentals = Fundamentals(new List<Symbol>{ nb, ibm }).ToList();

# Single asset
ibm = Symbol.create("IBM", SecurityType.EQUITY, Market.USA)
ibm_fundamental = self.fundamentals(ibm)

# Multiple assets
nb = Symbol.create("NB", SecurityType.EQUITY, Market.USA)
fundamentals = self.fundamentals([ nb, ibm ])

var ibm = QuantConnect.Symbol.Create("IBM", SecurityType.Equity, Market.USA);

// Fundamental objects
var fundamentalHistory = History<Fundamental>(ibm, TimeSpan.FromDays(30));

// Fundamentals objects for all US Equities (including delisted companies)
var fundamentalsHistory = History<Fundamentals>(TimeSpan.FromDays(30));

// Collection of Fundamental objects for all US Equities (including delisted companies)
var collectionHistory = History(_universe, 30, Resolution.Daily);
foreach (var fundamental in collectionHistory)
{
    // Cast to Fundamental is required
    var highestMarketCap = fundamental.OfType<Fundamental>().OrderByDescending(x => x.MarketCap).Take(5);
}

ibm = Symbol.create("IBM", SecurityType.EQUITY, Market.USA)

# DataFrame object where the columns are the Fundamental attributes
asset_df_history = self.history(Fundamental, ibm, timedelta(30), flatten=True)

# Fundamental objects
fundamental_history= self.history[Fundamental](ibm, timedelta(30))

# Fundamentals objects for all US Equities (including delisted companies)
fundamentals_history = self.history[Fundamentals](timedelta(30))

# Multi-index Series objects where the values are lists of Fundamental objects
series_history = self.history(self.universe, 30, Resolution.DAILY)
for (universe_symbol, time), fundamentals in series_history.items():
    highest_market_cap = sorted(fundamentals, key=lambda x: x.market_cap)[-5:]

# DataFrame object where the columns are the Fundamental attributes
universe_history_df = qb.universe_history(universe, qb.time-timedelta(30), qb.time, flatten=True)

# Multi-index Series objects where the values are lists of Fundamental objects
universe_history = qb.universe_history(universe, qb.time-timedelta(30), qb.time)
for (universe_symbol, time), fundamentals in universe_history.items():
    for fundamental in fundamentals:
        print(f"{fundamental.symbol} market cap at {fundamental.end_time}: {fundamental.market_cap}")

# DataFrame of a single Fundamental attribute
history = qb.get_fundamental(symbol, "ValuationRatios.pe_ratios", datetime(2021, 1, 1), datetime(2021, 7, 1))

var universeHistory = qb.UniverseHistory(universe, qb.Time.AddDays(-30), qb.Time);
foreach (var fundamentals in universeHistory)
{
    foreach (Fundamental fundamental in fundamentals)
    {
        Console.WriteLine($"{fundamental.Symbol} market cap at {fundamental.EndTime}: {fundamental.MarketCap}");
    }
}

var history = qb.GetFundamental(symbol, "ValuationRatios.PERatios", new DateTime(2021, 1, 1), new DateTime(2021, 7, 1));

filteredFundamentals = fundamental.Where(x =>
    x.AssetClassification.MorningstarSectorCode == MorningstarSectorCode.Technology);

filtered_fundamentals = [x for x in fundamental
    if x.asset_classification.morningstar_sector_code == MorningstarSectorCode.TECHNOLOGY]

filteredFundamentals = fundamental.Where(x =>
    x.AssetClassification.MorningstarIndustryGroupCode == MorningstarIndustryGroupCode.Software);

filtered_fundamentals = [x for x in fundamental
    if x.asset_classification.morningstar_industry_group_code == MorningstarIndustryGroupCode.SOFTWARE]