from AlgorithmImports import *
from QuantConnect.DataSource import *

class ExtractAlphaEstimizeAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2019, 1, 1)
        self.set_end_date(2020, 12, 31)
        self.set_cash(100000)
        
        # A variable to control the next rebalance time
        self.last_time = datetime.min
        
        self.add_universe(self.my_coarse_filter_function)
        self.universe_settings.resolution = Resolution.MINUTE
        
    def my_coarse_filter_function(self, coarse: List[CoarseFundamental]) -> List[Symbol]:
        # Select the non-penny stocks with the highest dollar volume, since they have more stable price (lower risk) and more informed insights from high market activities
        sorted_by_dollar_volume = sorted([x for x in coarse if x.has_fundamental_data and x.price > 4], 
                                key=lambda x: x.dollar_volume, reverse=True)
        selected = [x.symbol for x in sorted_by_dollar_volume[:500]]
        return selected

    def on_data(self, slice: Slice) -> None:
        if self.last_time > self.time: return
    
        # Accessing Estimize data to collect the crowd-sourced insighrt as trading signals
        consensus = slice.Get(EstimizeConsensus)
        estimate = slice.Get(EstimizeEstimate)
        release = slice.Get(EstimizeRelease)
        
        if not estimate: return
        
        # Long the ones with highest earning estimates and short the ones with lowest earning estimates, assuming the fundamental factor significance
        sorted_by_eps_estimate = sorted([x for x in estimate.items() if x[1].eps], key=lambda x: x[1].eps)
        long_symbols = [x[0].underlying for x in sorted_by_eps_estimate[-10:]]
        short_symbols = [x[0].underlying for x in sorted_by_eps_estimate[:10]]
        
        # Liquidate the ones that fall out of the earning extremes
        for symbol in [x.symbol for x in self.portfolio.Values if x.invested]:
            if symbol not in long_symbols + short_symbols:
                self.liquidate(symbol)
        
        # Invest equally and dollar-neutral to evenly dissipate capital risk and hedge systematic risk
        long_targets = [PortfolioTarget(symbol, 0.05) for symbol in long_symbols]
        short_targets = [PortfolioTarget(symbol, -0.05) for symbol in short_symbols]
        self.set_holdings(long_targets + short_targets)

        # Update the rebalance time to next month start
        self.last_time = Expiry.END_OF_MONTH(self.time)
        
    def on_securities_changed(self, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            # Requesting data for trading signal generation
            estimize_consensus_symbol = self.add_data(EstimizeConsensus, security.symbol).symbol
            estimize_estimate_symbol = self.add_data(EstimizeEstimate, security.symbol).symbol
            estimize_release_symbol = self.add_data(EstimizeRelease, security.symbol).symbol

            # Historical Data
            history = self.history([estimize_consensus_symbol,
                                    estimize_estimate_symbol,
                                    estimize_release_symbol
                                    ], 10, Resolution.DAILY)
            self.debug(f"We got {len(history)} items from our history request")

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class ExtractAlphaEstimizeAlgorithm : QCAlgorithm
    {
        // A variable to control the next rebalance time
        private DateTime _time = DateTime.MinValue;
        
        public override void Initialize()
        {
            SetStartDate(2019, 1, 1);
            SetEndDate(2020, 12, 31);
            SetCash(100000);
            
            AddUniverse(MyCoarseFilterFunction);
            UniverseSettings.Resolution = Resolution.Minute;
        }
        
        private IEnumerable<Symbol> MyCoarseFilterFunction(IEnumerable<CoarseFundamental> coarse)
        {
            // Select the non-penny stocks with the highest dollar volume, since they have more stable price (lower risk) and more informed insights from high market activities
            return (from c in coarse
                    where c.HasFundamentalData && c.Price > 4
                    orderby c.DollarVolume descending
                    select c.Symbol).Take(500);
        }
        
        public override void OnData(Slice slice)
        {
            if (_time > Time) return;
            
            // Accessing Estimize data to collect the crowd-sourced insighrt as trading signals
            var consensus = slice.Get<EstimizeConsensus>();
            var estimate = slice.Get<EstimizeEstimate>();
            var release = slice.Get<EstimizeRelease>();
            
            if (estimate.IsNullOrEmpty()) return;

            // Long the ones with highest earning estimates and short the ones with lowest earning estimates, assuming the fundamental factor significance
            var sortedByEpsEstimate = from value in estimate.Values
                            where (value.Eps != null)
                            orderby value.Eps descending
                            select value.Symbol.Underlying;
            var longSymbols = sortedByEpsEstimate.Take(10).ToList();
            var shortSymbols = sortedByEpsEstimate.TakeLast(10).ToList();
            
            // Liquidate the ones that fall out of the earning extremes
            foreach (var kvp in Portfolio)
            {
                var symbol = kvp.Key;
                if (kvp.Value.Invested && 
                !longSymbols.Contains(symbol) && 
                !shortSymbols.Contains(symbol))
                {
                    Liquidate(symbol);
                }
            }
            
            // Invest equally and dollar-neutral to evenly dissipate capital risk and hedge systematic risk
            var targets = new List<PortfolioTarget>();
            targets.AddRange(longSymbols.Select(symbol => new PortfolioTarget(symbol, 0.05m)));
            targets.AddRange(shortSymbols.Select(symbol => new PortfolioTarget(symbol, -0.05m)));
            
            SetHoldings(targets);

            // Update the rebalance time to next month start
            _time = Expiry.EndOfMonth(Time);
        }
        
        public override void OnSecuritiesChanged(SecurityChanges changes)
        {
            foreach(var security in changes.AddedSecurities)
            {
                // Requesting data for trading signal generation
                var consensusSymbol = AddData<EstimizeConsensus>(security.Symbol).Symbol;
                var estimateSymbol = AddData<EstimizeEstimate>(security.Symbol).Symbol;
                var releaseSymbol = AddData<EstimizeRelease>(security.Symbol).Symbol;
                
                // Historical Data
                var history = History(new[]{
                    consensusSymbol,
                    estimateSymbol,
                    releaseSymbol
                }, 10, Resolution.Daily);
                Debug($"We got {history.Count()} items from our history request");
            }
        }
    }
}

from AlgorithmImports import *
from QuantConnect.DataSource import *

class ExtractAlphaEstimizeFrameworkAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2019, 1, 1)
        self.set_end_date(2020, 12, 31)
        self.set_cash(100000)
        
        self.add_universe(self.my_coarse_filter_function)
        self.universe_settings.resolution = Resolution.MINUTE

        # Custom alpha model that emit signal according to Estimize data
        self.add_alpha(ExtractAlphaEstimizeAlphaModel())
        
        # Invest equally to evenly dissipate capital concentration risk
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())
        
        self.set_execution(ImmediateExecutionModel())
        
    def my_coarse_filter_function(self, coarse: List[CoarseFundamental]) -> List[Symbol]:
        # Select the non-penny stocks with the highest dollar volume, since they have more stable price (lower risk) and more informed insights from high market activities
        sorted_by_dollar_volume = sorted([x for x in coarse if x.has_fundamental_data and x.price > 4], 
                                key=lambda x: x.dollar_volume, reverse=True)
        selected = [x.symbol for x in sorted_by_dollar_volume[:500]]
        return selected
        
class ExtractAlphaEstimizeAlphaModel(AlphaModel):
    
    def __init__(self) -> None:
        # A variable to control the next rebalance time
        self.time = datetime.min
        
    def update(self, algorithm: QCAlgorithm, slice: Slice) -> List[Insight]:
        if self.time > algorithm.time: return []
        
        # Accessing Estimize data to collect the crowd-sourced insighrt as trading signals
        consensus = slice.Get(EstimizeConsensus)
        estimate = slice.Get(EstimizeEstimate)
        release = slice.Get(EstimizeRelease)
        
        if not estimate: return []

        # Long the ones with highest earning estimates and short the ones with lowest earning estimates, assuming the fundamental factor significance
        sorted_by_eps_estimate = sorted([x for x in estimate.items() if x[1].eps], key=lambda x: x[1].eps)
        long_symbols = [x[0].underlying for x in sorted_by_eps_estimate[-10:]]
        short_symbols = [x[0].underlying for x in sorted_by_eps_estimate[:10]]
        
        insights = []
        for symbol in long_symbols:
            insights.append(Insight.price(symbol, Expiry.END_OF_MONTH, InsightDirection.UP))
        for symbol in short_symbols:
            insights.append(Insight.price(symbol, Expiry.END_OF_MONTH, InsightDirection.DOWN))

        # Update the rebalance time to next month start
        self.time = Expiry.END_OF_MONTH(algorithm.time)
        
        return insights
        
    def on_securities_changed(self, algorithm: QCAlgorithm, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            # Requesting data for trading signal generation
            estimize_consensus_symbol = algorithm.add_data(EstimizeConsensus, security.symbol).symbol
            estimize_estimate_symbol = algorithm.add_data(EstimizeEstimate, security.symbol).symbol
            estimize_release_symbol = algorithm.add_data(EstimizeRelease, security.symbol).symbol
            
            # Historical Data
            history = algorithm.history([estimize_consensus_symbol,
                                         estimize_estimate_symbol,
                                         estimize_release_symbol
                                        ], 10, Resolution.DAILY)
            algorithm.debug(f"We got {len(history)} items from our history request")

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class ExtractAlphaEstimizeAlgorithm : QCAlgorithm
    {
        public override void Initialize()
        {
            SetStartDate(2019, 1, 1);
            SetEndDate(2021, 1, 1);
            SetCash(100000);
            
            AddUniverse(MyCoarseFilterFunction);
            UniverseSettings.Resolution = Resolution.Minute;

            // Custom alpha model that emit signal according to Estimize data
            AddAlpha(new ExtractAlphaEstimizeAlphaModel());

            // Invest equally to evenly dissipate capital concentration risk
            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
            
            SetExecution(new ImmediateExecutionModel());
        }
        
        private IEnumerable<Symbol> MyCoarseFilterFunction(IEnumerable<CoarseFundamental> coarse)
        {
            // Select the non-penny stocks with the highest dollar volume, since they have more stable price (lower risk) and more informed insights from high market activities
            return (from c in coarse
                    where c.HasFundamentalData && c.Price > 4
                    orderby c.DollarVolume descending
                    select c.Symbol).Take(500);
        }
    }
    
    public class ExtractAlphaEstimizeAlphaModel: AlphaModel
    {
        // A variable to control the next rebalance time
        public DateTime _time;
        
        public ExtractAlphaEstimizeAlphaModel()
        {
            _time = DateTime.MinValue;
        }
        
        public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice slice)
        {
            if (_time > algorithm.Time) return new List<Insight>();
            
            // Accessing Estimize data to collect the crowd-sourced insighrt as trading signals
            var consensus = slice.Get<EstimizeConsensus>();
            var estimate = slice.Get<EstimizeEstimate>();
            var release = slice.Get<EstimizeRelease>();
            
            if (estimate.IsNullOrEmpty()) return new List<Insight>();
            
            // Long the ones with highest earning estimates and short the ones with lowest earning estimates, assuming the fundamental factor significance
            var sortedByEpsEstimate = from s in estimate.Values
                            where (s.Eps != null)
                            orderby s.Eps descending
                            select s.Symbol.Underlying;
            var longSymbols = sortedByEpsEstimate.Take(10).ToList();
            var shortSymbols = sortedByEpsEstimate.TakeLast(10).ToList();
            
            var insights = new List<Insight>();
            insights.AddRange(longSymbols.Select(symbol => new Insight(symbol, Expiry.EndOfMonth, InsightType.Price, InsightDirection.Up)));
            insights.AddRange(shortSymbols.Select(symbol => new Insight(symbol, Expiry.EndOfMonth, InsightType.Price, InsightDirection.Down)));

            // Update the rebalance time to next month start
            _time = Expiry.EndOfMonth(algorithm.Time);
            
            return insights;
        }
        
        public override void OnSecuritiesChanged(QCAlgorithm algorithm, SecurityChanges changes)
        {
            foreach(var security in changes.AddedSecurities)
            {
                // Requesting data for trading signal generation
                var consensusSymbol = algorithm.AddData<EstimizeConsensus>(security.Symbol).Symbol;
                var estimateSymbol = algorithm.AddData<EstimizeEstimate>(security.Symbol).Symbol;
                var releaseSymbol = algorithm.AddData<EstimizeRelease>(security.Symbol).Symbol;
                
                // Historical Data
                var history = algorithm.History(new[]{
                    consensusSymbol,
                    estimateSymbol,
                    releaseSymbol
                }, 10, Resolution.Daily);
                algorithm.Debug($"We got {history.Count()} items from our history request");
            }
        }
    }
}