Historical Data

public class USEquityFundamentalUniverseHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 23);
        // Add a universe of US Equities based on the Fundamentals dataset.
        var universe = AddUniverse(fundamentals => fundamentals.Select(f => f.Symbol));
        // Get 5 days of history for the universe.
        var history = History(universe, TimeSpan.FromDays(5));
        // Iterate through each day of the universe history.
        foreach (var fundamentals in history)
        {
            // Iterate through each asset in the universe on this day and access its data point attributes.
            foreach (Fundamental f in fundamentals)
            {
                var symbol = f.Symbol;
                var t = f.EndTime;
                var peRatio = f.ValuationRatios.PERatio;
            }
        }
    }
}

class USEquityFundamentalUniverseHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 23)
        # Add a universe of US Equities based on the Fundamentals dataset.
        universe = self.add_universe(lambda fundamentals: [f.symbol for f in fundamentals])
        # Get 5 days of history for the universe.
        history = self.history(universe, timedelta(5), flatten=True)

public class ETFConstituentUniverseHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 23);
        // Add a universe of US Equities based on the constituents of an ETF.
        var universe = AddUniverse(Universe.ETF("SPY");
        // Get 5 days of history for the universe.
        var history = History(universe, TimeSpan.FromDays(5));
        // Iterate through each day of the universe history.
        foreach (var constituents in history)
        {
            // Select the 2 assets with the smallest weights in the ETF on this day.
            var dailyLargest = constituents.Select(c => c as ETFConstituentData).OrderBy(c => c.Weight).Take(2);
        }
    }
}

class ETFConstituentUniverseHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 23)
        # Add a universe of US Equities based on the constituents of an ETF.
        universe = self.add_universe(self.universe.etf('SPY'))
        # Get 5 days of history for the universe.
        history = self.history(universe, timedelta(5), flatten=True)

public class USEquityAltDataUniverseHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 23);
        // Add a universe of US Equities based on an alternative dataset.
        var universe = AddUniverse<BrainStockRankingUniverse>();
        // Get 5 days of history for the universe.
        var history = History(universe, TimeSpan.FromDays(5));
        // Iterate through each day of the universe history.
        foreach (var altCoarse in history)
        {
            // Select the asset with the greatest value each day.
            var dailyWinner = altCoarse
                .Select(c => c as BrainStockRankingUniverse)
                .OrderByDescending(c => c.Value)
                .First();
        }
    }
}

class USEquityAltDataUniverseHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 23)
        # Add a universe of US Equities based on an alternative dataset.
        universe = self.add_universe(BrainStockRankingUniverse)
        # Get 5 days of history for the universe.
        history = self.history(universe, timedelta(5), flatten=True)

public class EquityOptionUniverseHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 23);
        // Add a universe of Equity Option contracts.
        var option = AddOption("SPY");
        // Get 5 days of history for the universe.
        var history = History<OptionUniverse>(option.Symbol, TimeSpan.FromDays(5));
        // Iterate through each day of the universe history.
        foreach (var chain in history)
        {
            var t = chain.EndTime;
            // Select contracts that have open interest > 0 on this day.
            var openContracts = chain.Data
                .Select(contract => contract as OptionUniverse)
                .Where(contract => contract.OpenInterest > 0m);
        }
    }
}

class EquityOptionUniverseHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 23)
        # Add a universe of Equity Option contracts.
        option = self.add_option('SPY')
        # Get 5 days of history for the universe.
        history = self.history(option.symbol, timedelta(5), flatten=True)

public class IndexOptionsUniverseHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 23);
        // Add a universe of Index Option contracts.
        var option = AddIndexOption("VIX");
        // Get 5 days of history for the universe.
        var history = History<OptionUniverse>(option.Symbol, TimeSpan.FromDays(5));
        // Iterate through each day of the universe history.
        foreach (var chain in history)
        {
            var t = chain.EndTime;
            // Calculate the trading volume across all the contracts on this day.
            var dailyVolume = chain.Data
                .Select(contract => contract as OptionUniverse)
                .Sum(contract => contract.Volume);
        }
    }
}

class IndexOptionsUniverseHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 23)
        # Add a universe of Index Option contracts.
        option = self.add_index_option('VIX')
        # Get 5 days of history for the universe.
        history = self.history(option.symbol, timedelta(5), flatten=True)

public class CryptoUniverseHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 23);
        // Add a universe of Cryptocurrencies.
        var universe = AddUniverse(CryptoUniverse.Coinbase(data => data.Select(x => x.Symbol)));
        // Get 5 days of history for the universe.
        var history = History(universe, TimeSpan.FromDays(5));
        // Iterate through each day of the universe history.
        foreach (var universeDay in history)
        {
            var t = universeDay.EndTime;
            // Select the Crypto with the largest daily return on this day.
            var topGainer = universeDay
                .Select(c => c as CryptoUniverse)
                .OrderByDescending(c => (c.Close - c.Open) / c.Open)
                .First();
        }
    }
}

class CryptoUniverseHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 23)
        # Add a universe of Cryptocurrencies.
        universe = self.add_universe(CryptoUniverse.coinbase(lambda data: [x.symbol for x in data]))
        # Get 5 days of history for the universe.
        history = self.history(universe, timedelta(5), flatten=True)

public class CryptoMarketCapUniverseHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 24);
        // Add a universe of Cryptocurrencies.
        var universe = AddUniverse<CoinGecko>();
        // Get 365 days of history for the universe.
        var history = History(universe, TimeSpan.FromDays(365));
        // Iterate through each day of the universe history.
        foreach (var universeDay in history)
        {
            var t = universeDay.EndTime;
            // Select the Crypto with the largest market cap on this day.
            var largestCoin = universeDay.Select(c => c as CoinGecko).OrderByDescending(c => c.MarketCap).First();
        }
    }
}

class CryptoMarketCapUniverseHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 24)
        # Add a universe of Cryptocurrencies.
        universe = self.add_universe(CoinGeckoUniverse)
        # Get 355 days of history for the universe.
        history = self.history(universe, timedelta(365), flatten=True)

// Define the custom data class outside of the algorithm class.
public class StockDataSource : BaseData
{
    public List<string> Symbols { get; set; } = new();
    public override DateTime EndTime => Time.AddDays(1);

    public override SubscriptionDataSource GetSource(SubscriptionDataConfig config, DateTime date, bool isLiveMode)
    {
        return new SubscriptionDataSource(
            "https://raw.githubusercontent.com/QuantConnect/Documentation/master/Resources/datasets/custom-data/csv-universe-example.csv", 
            SubscriptionTransportMedium.RemoteFile, 
            FileFormat.Csv
        );
    }

    public override BaseData Reader(SubscriptionDataConfig config, string line, DateTime date, bool isLiveMode)
    {
        var stocks = new StockDataSource();
        stocks.Symbol = config.Symbol;
        try
        {
            var csv = line.Split(',');
            stocks.Time = DateTime.ParseExact(csv[0], "yyyyMMdd", null);
            stocks.Symbols.AddRange(csv.Skip(1));
        }
        catch { return null; }
        return stocks;
    }
}

public class CustomDataUniverseHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2018, 1, 10);
        // Add a custom data universe.
        var universe = AddUniverse<StockDataSource>("StockDataSource", Resolution.Daily);
        // Get the universe history.
        var history = History(universe, new DateTime(2018, 1, 1), new DateTime(2018, 1, 10)).Cast<StockDataSource>();
        // Iterate through each day in the universe history and count the number of constituents.
        foreach (var stockData in history)
        {
            var t = stockData.Time;
            var size = stockData.Symbols.Count;
        }
    }
}

# Define the custom data class outside of the algorithm class.    
class StockDataSource(PythonData):

    def get_source(self, config: SubscriptionDataConfig, date: datetime, is_live: bool) -> SubscriptionDataSource:
        return SubscriptionDataSource(
            "https://raw.githubusercontent.com/QuantConnect/Documentation/master/Resources/datasets/custom-data/csv-universe-example.csv", 
            SubscriptionTransportMedium.REMOTE_FILE, 
            FileFormat.CSV
        )

    def reader(self,config: SubscriptionDataConfig, line: str, date: datetime, is_live: bool) -> BaseData:
        if not (line.strip() and line[0].isdigit()): 
            return None
        stocks = StockDataSource()
        stocks.symbol = config.symbol
        try:
            csv = line.split(',')
            stocks.time = datetime.strptime(csv[0], "%Y%m%d")
            stocks.end_time = stocks.time + timedelta(days=1)
            stocks["Symbols"] = csv[1:]
        except ValueError:
            return None
        return stocks


class CustomDataUniverseHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2018, 1, 10)
        # Add a custom data universe.
        universe = self.add_universe(StockDataSource)
        # Get the universe history.
        history = self.history(universe, datetime(2018, 1, 1), datetime(2018, 1, 10), flatten=True)