def initialize(self) -> None:
    self._universe = self.add_universe(EODHDUpcomingSplits, self.universe_selection_filter)

def universe_selection_filter(self, splits: List[EODHDUpcomingSplits]) -> List[Symbol]:
    return [d.symbol for d in splits if d.split_date <= self.time + timedelta(3) and d.split_factor > 1]

public override void Initialize()
{
    _universe = AddUniverse<EODHDUpcomingSplits>(UniverseSelectionFilter);
}

private IEnumerable<Symol> UniverseSelectionFilter(IEnumerable<EODHDUpcomingSplits> splits)
{
    return from d in splits
           where d.SplitDate <= Time.AddDays(3) && d.SplitFactor > 1m
           select d.Symbol;
}

class UpcomingSplitsDataAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2019, 1, 1)
        self.set_end_date(2020, 6, 1)
        self.set_cash(100000)

        self._symbol = self.add_equity("AAPL", Resolution.DAILY).symbol
        self.dataset_symbol = self.add_data(EODHDUpcomingSplits, "splits").symbol

namespace QuantConnect.Algorithm.CSharp.AltData
{
    public class UpcomingSplitsDataAlgorithm : QCAlgorithm
    {
        private Symbol _symbol, _datasetSymbol;

        public override void Initialize()
        {
            SetStartDate(2019, 1, 1);
            SetEndDate(2020, 6, 1);
            SetCash(100000);
            _symbol = AddEquity("AAPL", Resolution.Daily).Symbol;
            _datasetSymbol = AddData<EODHDUpcomingSplits>("splits").Symbol;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    upcomings_splits = slice.get(EODHDUpcomingSplits)
    if upcomings_splits and self._symbol in upcomings_splits:
        upcomings_splits_data_point = upcomings_splits[self._symbol]
        self.log(f"{self._symbol} will split at {upcomings_splits_data_point.split_date} with split factor {upcomings_splits_data_point.split_factor}")

public override void OnData(Slice slice)
{
    var upcomingSplits = slice.Get<EODHDUpcomingSplits>();
    if (upcomingSplits.TryGetValue(_symbol, out var upcomingSplitsDataPoint))
    {
        Log($"{_symbol} will split at {upcomingSplitsDataPoint.SplitDate} with split factor {upcomingSplitsDataPoint.SplitFactor}");
    }
}

def on_data(self, slice: Slice) -> None:
    for equity_symbol, upcomings_splits_data_point in slice.get(EODHDUpcomingSplits).items():
        self.log(f"{equity_symbol} will split at {upcomings_splits_data_point.split_date} with split factor {upcomings_splits_data_point.split_factor}")

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Get<EODHDUpcomingSplits>())
    {
        var equitySymbol = kvp.Key;
        var upcomingSplitsDataPoint = kvp.Value;
        Log($"{equitySymbol} will splits at {upcomingSplitsDataPoint.SplitDdate} with split factor {upcomingSplitsDataPoint.SplitFactor}");
    }
}

history = self.history[EODHDUpcomingSplits](timedelta(100), Resolution.DAILY)

var history = History<EODHDUpcomingSplits>(TimeSpan.FromDays(100), Resolution.Daily);

self.remove_security(self.dataset_symbol)

RemoveSecurity(_datasetSymbol);

class UpcomingSplitsExampleAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2024, 10, 1)
        self.set_cash(100000)

        # Trade on daily basis based on daily upcoming splits signals.
        self.universe_settings.resolution = Resolution.DAILY
        # Universe consists of equities with upcoming splits events.
        self._universe = self.add_universe(EODHDUpcomingSplits, self.selection)
    
    def selection(self, splits: List[EODHDUpcomingSplits]) -> List[Symbol]:
        # Split (more shares with lower price) will make the stock more affordable and drive up the demand.
        # Hence, include all stocks that will have a split within the next 7 days.
        # Note that spliting up the stock means the split factor > 1.
        return [x.symbol for x in splits if x.split_factor > 1]
    
    def on_data(self, slice: Slice) -> None:
        # Equally invest in each member of the universe to evenly dissipate the capital risk.
        total_count = len(self._universe.members)
        targets = [PortfolioTarget.percent(self, symbol, 1. / total_count) for symbol in self._universe.members.keys()]
        self.set_holdings(targets)

    def on_securities_changed(self, changes: SecurityChanges) -> None:
        for removed in changes.removed_securities:
            # Liquidate the ones exit the universe (already split) to capitalize the microeconomic demand.
            self.liquidate(removed.symbol)

namespace QuantConnect
{
    public class UpcomingSplitsExampleAlgorithm : QCAlgorithm
    {
        private Universe _universe;

        public override void Initialize()
        {
            SetStartDate(2020, 1, 1);
            SetEndDate(2024, 10, 1);
            SetCash(100000);

            // Trade on daily basis based on daily upcoming earnings signals.
            UniverseSettings.Resolution = Resolution.Daily;
            // Universe consists of equities with upcoming earnings events.
            _universe = AddUniverse<EODHDUpcomingSplits>((splits) => {
                return splits
                    // Split (more shares with lower price) will make the stock more affordable and drive up the demand.
                    // Hence, include all stocks that will have a split within the next 7 days.
                    // Note that spliting up the stock means the split factor > 1.
                    .Where(datum => (datum as EODHDUpcomingSplits).SplitFactor > 1)
                    .Select(datum => datum.Symbol);
            });
        }

        public override void OnData(Slice slice)
        {
            // Equally invest in each member of the universe to evenly dissipate the capital risk.
            var totalCount = _universe.Members.Count;
            var targets = _universe.Members.Keys
                .Select(symbol => (PortfolioTarget)PortfolioTarget.Percent(this, symbol, 1m / totalCount))
                .ToList();
            SetHoldings(targets);
        }

        public override void OnSecuritiesChanged(SecurityChanges changes)
        {
            foreach (var removed in changes.RemovedSecurities)
            {
                // Liquidate the ones exit the universe (already split) to capitalize the microeconomic demand.
                Liquidate(removed.Symbol);
            }
        }
    }
}

class UpcomingSplitsExampleAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2024, 10, 1)
        self.set_cash(100000)

        # Trade on daily basis based on daily upcoming splits signals.
        self.universe_settings.resolution = Resolution.DAILY
        # Universe consists of equities with upcoming splits events.
        self._universe = self.add_universe(EODHDUpcomingSplits, self.selection)

        # Constant alpha model to emit insights for the stocks with split up event within a week, estimating their demand and price will go up.
        # Signal stays for 2 days to fully digest the driven up demands.
        self.add_alpha(ConstantAlphaModel(InsightType.PRICE, InsightDirection.UP, timedelta(2)))

        # Equal weighting for each signal to evenly dissipate the capital risk.
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel(Expiry.END_OF_DAY))
    
    def selection(self, splits: List[EODHDUpcomingSplits]) -> List[Symbol]:
        # Split (more shares with lower price) will make the stock more affordable and drive up the demand.
        # Hence, include all stocks that will have a split within the next 7 days.
        # Note that spliting up the stock means the split factor > 1.
        return [x.symbol for x in splits if x.split_factor > 1]

namespace QuantConnect
{
    public class UpcomingSplitsExampleAlgorithm : QCAlgorithm
    {
        private Universe _universe;

        public override void Initialize()
        {
            SetStartDate(2020, 1, 1);
            SetEndDate(2024, 10, 1);
            SetCash(100000);

            // Trade on daily basis based on daily upcoming splits signals.
            UniverseSettings.Resolution = Resolution.Daily;
            // Universe consists of equities with upcoming splits events.
            _universe = AddUniverse<EODHDUpcomingSplits>((splits) => {
                return splits
                    // Split (more shares with lower price) will make the stock more affordable and drive up the demand.
                    // Hence, include all stocks that will have a split within the next 7 days.
                    // Note that spliting up the stock means the split factor > 1.
                    .Where(datum => (datum as EODHDUpcomingSplits).SplitFactor > 1)
                    .Select(datum => datum.Symbol);
            });

            // Constant alpha model to emit insights for the stocks with split up event within a week, estimating their demand and price will go up.
            // Signal stays for 2 days to fully digest the driven up demands.
            AddAlpha(new ConstantAlphaModel(InsightType.Price, InsightDirection.Up, TimeSpan.FromDays(2)));

            // Equal weighting for each signal to evenly dissipate the capital risk.
            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel(Expiry.EndOfDay));
        }
    }
}