Historical Data

// Get the latest 3 data points of all the securities/datasets in the notebook, packaged into Slice objects.
var history = History(3);

# Get the latest 3 data points of all the securities/datasets in the notebook, packaged into Slice objects.
history = self.history(3)

public class CustomSecurityHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2014, 7, 10);
        // Add a custom dataset and save a reference to it's Symbol.
        var datasetSymbol = AddData<MyCustomDataType>("MyCustomDataType", Resolution.Daily).Symbol;
        // Get the trailing 5 days of MyCustomDataType data.
        var history = History<MyCustomDataType>(datasetSymbol, 5, Resolution.Daily);
    }
}

class CustomSecurityHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2014, 7, 10)
        # Add a custom dataset and save a reference to it's Symbol.
        dataset_symbol = self.add_data(MyCustomDataType, "MyCustomDataType", Resolution.DAILY).symbol
        # Get the trailing 5 days of MyCustomDataType data in DataFrame format.
        history = self.history(dataset_symbol, 5, Resolution.DAILY)

public class CustomDataUniverseHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2017, 7, 9);
        // Add a universe from a custom data source and save a reference to it.
        var universe = AddUniverse<StockDataSource>(
            "myStockDataSource", Resolution.Daily, data => data.Select(x => x.Symbol)
        );
        // Get the historical universe data over the last 5 days.
        var history = History(universe, TimeSpan.FromDays(5)).Cast<StockDataSource>().ToList();
        // 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;
        }
    }
}

class CustomDataUniverseHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2017, 7, 9)
        # Add a universe from a custom data source and save a reference to it.
        universe = self.add_universe(
            StockDataSource, "my-stock-data-source", Resolution.DAILY, lambda data: [x.symbol for x in data]
        )
        # Get the historical universe data over the last 5 days in DataFrame format.
        history = self.history(universe, timedelta(5))

public class CustomUniverseExampleAlgorithm : QCAlgorithm
{
    private const decimal SmoothingFactor = 2m / (1m + 5m);
    private Universe _universe;

    public override void Initialize()
    {
        SetStartDate(2016, 1, 1);
        SetEndDate(2025, 1, 1);
        // Add a universe that reads from the Object Store.
        _universe = AddUniverse<CustomUniverseData>("CustomUniverse", Resolution.Daily, (altCoarse) => {
            return altCoarse.Select(d => d.Symbol);
        });
        // Add a Scheduled Event to rebalance the portfolio.
        var spy = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);
        Schedule.On(
            DateRules.EveryDay(spy), 
            TimeRules.AfterMarketOpen(spy, 1), 
            Rebalance
        );
    }

    private void Rebalance()
    {
        // We invest by the EMA of the given weight.
        var history = History(_universe, 5, Resolution.Daily);
        var symbols = history.Select(x => x.Symbol).ToHashSet();
        var weights = symbols.Select(symbol => {
                var ema = history.Where(x => x.Symbol == symbol)
                    .Select(x => (x as CustomUniverseData).Weight)
                    .Aggregate((ema, nextQuote) => SmoothingFactor * nextQuote + (1m - SmoothingFactor) * ema);
                return (symbol, ema);
            }).ToList();
        // Normalized weights.
        var weightSum = weights.Sum(x => x.Item2);
        var targets = weights.Select(x => new PortfolioTarget(x.Item1, x.Item2 / weightSum)).ToList();
        SetHoldings(targets, liquidateExistingHoldings: true);
    }
}

public class CustomUniverseData : BaseDataCollection
{
    public decimal Weight;
    public override DateTime EndTime 
    {
        // Set the data period to 1 day.
        get { return Time + QuantConnect.Time.OneDay; }
        set { Time = value - QuantConnect.Time.OneDay; }
    }

    public override SubscriptionDataSource GetSource(SubscriptionDataConfig config, DateTime date, bool isLiveMode)
    {
        // Define the location and format of the data file.
        return new SubscriptionDataSource(
            "portfolioTargets.csv", SubscriptionTransportMedium.ObjectStore, FileFormat.Csv
        );
    }

    public override BaseData Reader(SubscriptionDataConfig config, string line, DateTime date, bool isLiveMode) 
    {
        // Skip the header row.
        if (!Char.IsDigit(line[0]))
        {
            return null;
        }
        // Split the line by each comma.
        var items = line.Split(",");

        // Parse the data from the CSV file.
        return new CustomUniverseData 
        {
            EndTime = Parse.DateTimeExact(items[0], "yyyy-MM-dd"),
            Symbol = Symbol.Create(items[1], SecurityType.Equity, Market.USA),
            Weight = decimal.Parse(items[2], NumberStyles.Any, CultureInfo.InvariantCulture)
        };
    }
}

class CustomUniverseExampleAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2016, 1, 1)
        self.set_end_date(2025, 1, 1)
        # Add a universe that reads from the Object Store.
        self._universe = self.add_universe(
            CustomUniverseData, "CustomUniverse", Resolution.DAILY, lambda x: [y.symbol for y in x]
        )
        # Add a Scheduled Event to rebalance the portfolio.
        spy = Symbol.create('SPY', SecurityType.EQUITY, Market.USA)
        self.schedule.on(
            self.date_rules.every_day(spy),
            self.time_rules.after_market_open(spy, 1),
            self.rebalance
        )

    def rebalance(self) -> None:
        # We invest by the EMA of the given weight.
        history = self.history(self._universe, 5, Resolution.DAILY).set_index('symbol', append=True).unstack('symbol').fillna(0)
        weights = history.ewm(5).mean().iloc[-1].droplevel(0)
        # Normalized weights.
        weights = weights / weights.sum()
        self.set_holdings([PortfolioTarget(symbol, weight) for symbol, weight in weights.items()], liquidate_existing_holdings=True)


class CustomUniverseData(PythonData):
    def get_source(self, config: SubscriptionDataConfig, date: datetime, is_live_mode: bool) -> SubscriptionDataSource:
        # Define the location and format of the data file.
        return SubscriptionDataSource(
            "portfolio-targets.csv", SubscriptionTransportMedium.OBJECT_STORE, FileFormat.CSV
        )

    def reader(self, config: SubscriptionDataConfig, line: str, date: datetime, is_live_mode: bool) -> BaseData:
        # Skip the header row.
        if not line[0].isnumeric():
            return None
        # Split the line by each comma.
        items = line.split(",")
        # Parse the data from the CSV file.
        data = CustomUniverseData()
        data.end_time = datetime.strptime(items[0], "%Y-%m-%d")
        data.time = data.end_time - timedelta(1)
        data['symbol'] = Symbol.create(items[1], SecurityType.EQUITY, Market.USA)
        data["weight"] = float(items[2])
        return data