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

def universe_selection_filter(self, dividends: List[EODHDUpcomingDividends]) -> List[Symbol]:
    return [d.symbol for d in dividends if d.dividend_date <= self.time + timedelta(1) and d.dividend > 0.05]

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

private IEnumerable<Symol> UniverseSelectionFilter(IEnumerable<BaseData> dividends)
{
    return from EODHDUpcomingDividends d in dividends
           where d.DividendsDate <= Time.AddDays(1) && d.Dividends > 0.05m
           select d.Symbol;
}

class UpcomingDividendsDataAlgorithm(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(EODHDUpcomingDividends, "dividends").symbol

namespace QuantConnect.Algorithm.CSharp.AltData
{
    public class UpcomingDividendsDataAlgorithm : 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<EODHDUpcomingDividends>("dividends").Symbol;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    upcomings_dividends = slice.get(EODHDUpcomingDividends)
    if upcomings_dividends and self._symbol in upcomings_dividends:
        upcomings_dividends_data_point = upcomings_dividends[self._symbol]
        self.log(f"{self._symbol} will pay dividend at {upcomings_dividends_data_point.dividend_date} with dividend per share of ${upcomings_dividends_data_point.dividend}")

public override void OnData(Slice slice)
{
    var upcomingDividends = slice.Get<EODHDUpcomingDividends>();
    if (upcomingDividends.TryGetValue(_symbol, out var upcomingDividendsDataPoint))
    {
        Log($"{_symbol} will pay dividend at {upcomingDividendsDataPoint.DividendDate} with dividend per share of ${upcomingDividendsDataPoint.Dividend}");
    }
}

def on_data(self, slice: Slice) -> None:
    for equity_symbol, upcomings_dividends_data_point in slice.get(EODHDUpcomingDividends).items():
        self.log(f"{equity_symbol} will pay dividend at {upcomings_dividends_data_point.dividend_date} with dividend per share of ${upcomings_dividends_data_point.dividend}")

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Get<EODHDUpcomingDividends>())
    {
        var equitySymbol = kvp.Key;
        var upcomingDividendsDataPoint = kvp.Value;
        Log($"{equitySymbol} will pay dividend at {upcomingDividendsDataPoint.DividendDate} with dividend per share of ${upcomingDividendsDataPoint.Dividend}");
    }
}

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

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

self.remove_security(self.dataset_symbol)

RemoveSecurity(_datasetSymbol);

class UpcomingDividendsExampleAlgorithm(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 a daily basis based on daily upcoming dividend signals.
        self.universe_settings.resolution = Resolution.DAILY
        # Universe consists of equities with upcoming dividend events.
        self._universe = self.add_universe(EODHDUpcomingDividends, self.selection)
    
    def selection(self, dividends: List[EODHDUpcomingDividends]) -> List[Symbol]:
        # Select the stocks with upcoming dividend record date, with a sufficient dividend size.
        return [x.symbol for x in dividends if x.dividend_date < self.time + timedelta(1) and x.dividend > 0.5]
    
    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.selected)
        targets = [PortfolioTarget.percent(self, symbol, -1. / total_count) for symbol in self._universe.selected]
        self.set_holdings(targets, liquidate_existing_holdings=True)

namespace QuantConnect
{
    public class UpcomingDividendsExampleAlgorithm : 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 dividend signals.
            UniverseSettings.Resolution = Resolution.Daily;
            // Universe consists of equities with upcoming dividend events.
            _universe = AddUniverse<EODHDUpcomingDividends>((dividends) => {
                // Select the stocks with upcoming dividend record date, with a sufficient dividend size.
                return from EODHDUpcomingDividends d in dividends
                       where d.DividendDate < Time.AddDays(1) && d.Dividend > 0.5
                       select d.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.Selected
                .Select(symbol => (PortfolioTarget)PortfolioTarget.Percent(this, symbol, -1m / totalCount))
                .ToList();
            SetHoldings(targets, liquidateExistingHoldings=true);
        }
    }
}

class UpcomingDividendsExampleAlgorithm(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 a daily basis based on upcoming dividend signals daily.
        self.universe_settings.resolution = Resolution.DAILY
        # Universe consists of equities with upcoming dividend events.
        self._universe = self.add_universe(EODHDUpcomingDividends, self.selection)

        # A constant alpha model will emit insights for the stocks with dividend events in the upcoming day.
        # It is expecting a price shock due to pricing after the dividend, which might affect some momentum traders.
        self.add_alpha(ConstantAlphaModel(InsightType.PRICE, InsightDirection.DOWN, timedelta(1)))

        # Equal weighting for each signal to dissipate the capital risk evenly.
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel(Expiry.END_OF_DAY))
    
    def selection(self, splits: List[EODHDUpcomingDividends]) -> List[Symbol]:
        # Select the stocks with upcoming dividend record dates with a sufficient dividend size.
        return [x.symbol for x in dividends if x.dividend_date < self.time + timedelta(1) and x.dividend > 0.5]

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

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

            // Trade on a daily basis based on upcoming dividend signals daily.
            UniverseSettings.Resolution = Resolution.Daily;
            // Universe consists of equities with upcoming dividend events.
            _universe = AddUniverse<EODHDUpcomingDividends>((dividends) => {
                // Select the stocks with upcoming dividend record dates with a sufficient dividend size.
                return from EODHDUpcomingDividends d in dividends
                       where d.DividendDate < Time.AddDays(1) && d.Dividend > 0.5
                       select d.Symbol;
            });

            // A constant alpha model will emit insights for the stocks with dividend events in the upcoming day.
            // It is expecting a price shock due to pricing after the dividend, which might affect some momentum traders.
            AddAlpha(new ConstantAlphaModel(InsightType.Price, InsightDirection.Down, TimeSpan.FromDays(1)));

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