from AlgorithmImports import *
from QuantConnect.DataSource import *

class USEquityCoarseUniverseConstituentsDataAlgorithm(QCAlgorithm):

    _number_of_symbols = 3
    _changes = None

    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2021, 7, 1)
        self.set_cash(100000)
        # Set Asynchronous to True to improve speed performance
        self.universe_settings.asynchronous = True
        # Requesting data
        self.add_universe(self.fundamental_selection_function)

    def fundamental_selection_function(self, fundamental: List[Fundamental]) -> List[Symbol]:
        # Select the top traded stocks, since they are the most popular with high capital flow
        sortedByDollarVolume = sorted(fundamental, key=lambda x: x.dollar_volume, reverse=True)
        return [ x.symbol for x in sortedByDollarVolume[:self._number_of_symbols] ]

    def on_data(self, slice: Slice) -> None:
        # if we have no changes, do nothing
        if self._changes is None: return

        # liquidate removed securities, since they are not the most popular stocks
        for security in self._changes.removed_securities:
            if security.invested:
                self.liquidate(security.symbol)

        # we want 1/N allocation in each security in our universe to evenly dissipate risk
        for security in self._changes.added_securities:
            self.set_holdings(security.symbol, 1 / self._number_of_symbols)

        self._changes = None

    def on_securities_changed(self, changes: SecurityChanges) -> None:
        self._changes = changes
        
        for security in changes.added_securities:
            # Historical data
            history = self.history(security.symbol, 7, Resolution.DAILY)
            self.debug(f"We got {len(history)} from our history request for {security.symbol}") 

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class USEquityCoarseUniverseConstituentsDataAlgorithm : QCAlgorithm
    {
        private int _numberOfSymbols = 3;
        private SecurityChanges _changes = SecurityChanges.None;
        
        public override void Initialize()
        {
            SetStartDate(2021, 1, 1);
            SetEndDate(2021, 7, 1);
            SetCash(100000);
        
            // Set Asynchronous to true to improve speed performance 
            UniverseSettings.Asynchronous = true;
            // Requesting data
            AddUniverse(FundamentalSelectionFunction);
        }

        public IEnumerable<Symbol> FundamentalSelectionFunction(IEnumerable<Fundamental> fundamental)
        {
            // Select the top traded stocks, since they are the most popular with high capital flow
            return fundamental.OrderByDescending(x => x.DollarVolume)
                .Take(_numberOfSymbols).Select(x => x.Symbol);
        }

        public override void OnData(Slice slice)
        {
            // if we have no changes, do nothing
            if (_changes == SecurityChanges.None) return;

            // liquidate removed securities, since they are not the most popular stocks
            foreach (var security in _changes.RemovedSecurities)
            {
                if (security.Invested)
                {
                    Liquidate(security.Symbol);
                }
            }

            // we want 1/N allocation in each security in our universe to evenly dissipate risk
            foreach (var security in _changes.AddedSecurities)
            {
                SetHoldings(security.Symbol, 1m / _numberOfSymbols);
            }

            _changes = SecurityChanges.None;
        }
        
        public override void OnSecuritiesChanged(SecurityChanges changes)
        {
            _changes = changes;


            foreach (var security in changes.AddedSecurities)
            {
                // Historical data
                var history = History(security.Symbol, 7, Resolution.Daily);
                Debug($"We got {history.Count()} from our history request for {security.Symbol}");
            }
        }
    }
}

from AlgorithmImports import *
from QuantConnect.DataSource import *

class USEquityCoarseUniverseConstituentsDataAlgorithm(QCAlgorithm):

    _number_of_symbols = 3

    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2021, 7, 1)
        self.set_cash(100000)

        # Set Asynchronous to True to improve speed performance
        self.universe_settings.asynchronous = True
            
        # Requesting data
        self.set_universe_selection(
            FundamentalUniverseSelectionModel(self.fundamental_selection_function))
        
        # we want 1/N allocation in each security in our universe to evenly dissipate risk
        self.set_alpha(ConstantAlphaModel(InsightType.PRICE, InsightDirection.UP, timedelta(1)))
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())
         
        self.add_risk_management(NullRiskManagementModel())
        
        self.set_execution(ImmediateExecutionModel())

    def fundamental_selection_function(self, fundamental: List[Fundamental]) -> List[Symbol]:
        # Select the top traded stocks, since they are the most popular with high capital flow
        sortedByDollarVolume = sorted(fundamental, key=lambda x: x.dollar_volume, reverse=True)
        return [ x.symbol for x in sortedByDollarVolume[:self._number_of_symbols] ]

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class USEquityCoarseUniverseConstituentsDataAlgorithm : QCAlgorithm
    {
        private int _numberOfSymbols = 3;
        
        public override void Initialize()
        {
            SetStartDate(2021, 1, 1);
            SetEndDate(2021, 7, 1);
            SetCash(100000);

            // Set Asynchronous to true to improve speed performance
            UniverseSettings.Asynchronous = true;

            // Requesting data
            SetUniverseSelection(
                new FundamentalUniverseSelectionModel(FundamentalSelectionFunction));

            // we want 1/N allocation in each security in our universe to evenly dissipate risk
            SetAlpha(new ConstantAlphaModel(InsightType.Price, InsightDirection.Up, TimeSpan.FromDays(1)));
            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
            
            AddRiskManagement(new NullRiskManagementModel());
            
            SetExecution(new ImmediateExecutionModel());
        }

        public IEnumerable<Symbol> FundamentalSelectionFunction(IEnumerable<Fundamental> fundamental)
        {
            // Select the top traded stocks, since they are the most popular with high capital flow
            return fundamental.OrderByDescending(x => x.DollarVolume)
                .Take(_numberOfSymbols).Select(x => x.Symbol);
        }
    }
}

var qb = new QuantBook();

// Add Fundamental Universe Selection
IEnumerable<Symbol> FundamentalSelectionFunction(IEnumerable<Fundamental> fundamentals)
{
    return fundamentals.OrderByDescending(x => c.DollarVolume).Take(10).Select(x => c.Symbol);
}

var universe = qb.AddUniverse(FundamentalSelectionFunction); 

// Historical Universe data
var universeHistory = qb.UniverseHistory(universe, qb.Time.AddDays(-30), qb.Time);
foreach (var fundamentals in universeHistory)
{
    foreach (Fundamental fundamental in fundamentals)
    {
        Console.WriteLine($"{fundamental.Symbol} dollar volume at {fundamental.EndTime}: {fundamental.DollarVolume}");
    }
}

qb = QuantBook()

# Add Fundamental Universe Selection
def fundamental_selection_function(fundamentals):
    selected = sorted(fundamentals, key=lambda x: x.dollar_volume, reverse=True)[:10]
    return [x.symbol for x in selected]

universe = qb.add_universe(fundamental_selection_function)

# Historical Universe data
universe_history = qb.universe_history(universe, qb.time-timedelta(30), qb.time)
for (universe_symbol, time), fundamentals in universe_history.items():
    for fundamental in fundamentals:
        print(f"{fundamental.symbol} dollar volume at {fundamental.end_time}: {fundamental.dollar_volume}")