Equity

using System.Collections.Generic;
using System.Linq;
using QuantConnect.Util;
using QuantConnect.Data;
using QuantConnect.DataSource;
using QuantConnect.Data.UniverseSelection;
using QuantConnect.Securities;
    
namespace QuantConnect.Algorithm.CSharp
{
    public class ChainedUniverseAlgorithm : QCAlgorithm
    {
        private List<Symbol> _fundamental = new();

        public override void Initialize()
        {
            SetStartDate(2023, 1, 2);
            SetCash(100000);

            // Filter the top 100 liquid equities of the last trading day, and save the symbols for the next filtering.
            AddUniverse(fundamental =>
            {
                _fundamental = (from c in fundamental
                    orderby c.DollarVolume descending
                    select c.Symbol).Take(100).ToList();
                return Universe.Unchanged;
            });
            // Filter the equities being commented on by CNBC analyst Cramer, then select the ones that intersect with the fundamental universe.
            AddUniverse<QuiverCNBCsUniverse>(altCoarse =>
            {
                var followers = from d in altCoarse.OfType<QuiverCNBCsUniverse>()
                    where d.Traders.ToLower().Contains("cramer")
                    select d.Symbol;
                return _fundamental.Intersect(followers);
            });
        }

        public override void OnSecuritiesChanged(SecurityChanges changes)
        {
            // Request CNBC data for the selected stocks.
            foreach (var added in changes.AddedSecurities)
            {
                AddData<QuiverCNBCs>(added.Symbol);
            }
        }
    
        public override void OnData(Slice data)
        {
            foreach (var dataPoint in data.Get<QuiverCNBCs>().SelectMany(x=> x.Value.OfType<QuiverCNBC>()))
            {
                Debug($"{dataPoint.Symbol} traders at {data.Time}: {dataPoint.Traders}");
            }
        }
    }
}

from AlgorithmImports import *

class ChainedUniverseAlgorithm(QCAlgorithm):

    _fundamental = []

    def initialize(self) -> None:
        self.set_start_date(2023, 1, 2)
        self.set_cash(100000)
        self.add_universe(self._fundamental_filter_function)
        self.add_universe(QuiverCNBCsUniverse, self._mad_money_selection)
    
    def _fundamental_filter_function(self, fundamental: List[Fundamental]) -> List[Symbol]:
        # Filter the top 100 liquid equities of the last trading day, and save the symbols for the next filtering.
        sorted_by_dollar_volume = sorted(fundamental, key=lambda x: x.dollar_volume, reverse=True) 
        self.fundamental = [c.symbol for c in sorted_by_dollar_volume[:100]]
        return Universe.UNCHANGED
    
    def _mad_money_selection(self, alt_coarse: List[QuiverCNBCsUniverse]) -> List[Symbol]:
        # Filter the equities being commented on by CNBC analyst Cramer, then select the ones that intersect with the fundamental universe.
        madmoney = [d.symbol for d in alt_coarse if 'Cramer' in d.traders]
        return list(set(self._fundamental) & set(madmoney))
    
    def on_securities_changed(self, changes: SecurityChanges) -> None:
        # Request CNBC data for the selected stocks.
        for added in changes.added_securities:
            self.add_data(QuiverCNBCs, added.symbol)
    
    def on_data(self, data: Slice) -> None:
        # Prices in the slice from the universe selection
        # Alternative data in a slice from OnSecuritiesChanged Addition
        # for ticker,bar in data.bars.items():
        #     pass
        for dataset_symbol, data_points in data.get(QuiverCNBCs).items():
            for data_point in data_points:
                self.debug(f"{dataset_symbol} traders at {data.time}: {data_point.traders}")

using QuantConnect.Data;
using QuantConnect.Data.Fundamental;
using QuantConnect.Data.UniverseSelection;
using QuantConnect.Securities;
using QuantConnect.Util;
using System.Collections.Generic;
using System.Linq;

namespace QuantConnect.Algorithm.CSharp
{
    public class ETFUniverseOptions : QCAlgorithm
    {
        public override void Initialize()
        {
            SetStartDate(2023, 2, 2);
            SetCash(100000);
            UniverseSettings.Asynchronous = true;
            // Need to set data normalization mode to raw for options to compare the strike price fairly.
            UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;

            // Filter for equities with fundamental data first.
            var universe = AddUniverse(FundamentalFunction);
            // Based on the filtered equities, request an option universe with them as underlying.
            AddUniverseOptions(universe, OptionFilterFunction);
        }

        private IEnumerable<Symbol> FundamentalFunction(IEnumerable<Fundamental> fundamental)
        {
            // Filter for equities with the lowest PE Ratio first.
            return fundamental
                .Where(f => !double.IsNaN(f.ValuationRatios.PERatio))
                .OrderBy(f => f.ValuationRatios.PERatio)
                .Take(10)
                .Select(x => x.Symbol);
        }
    
        private OptionFilterUniverse OptionFilterFunction(OptionFilterUniverse optionFilterUniverse)
        {
            // Select the front month ATM calls.
            return optionFilterUniverse.Strikes(0, 2).FrontMonth().CallsOnly();
        }
    
        public override void OnData(Slice data)
        {
            // Iterate each option chain to assert the contracts being selected.
            foreach (var (symbol, chain) in data.OptionChains)
            {
                foreach (var contract in chain)
                {
                    Debug($"Found {contract.Symbol} option contract for {symbol}");
                }
            }
        }
    }
}