from AlgorithmImports import *
from QuantConnect.DataSource import *

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

        self.universe_settings.resolution = Resolution.DAILY
        # Filter using wall street bet insights
        self._universe = self.add_universe(QuiverWallStreetBetsUniverse, self.universe_selection)

    def on_data(self, slice: Slice) -> None:
        points = slice.Get(QuiverWallStreetBets)
        for point in points.Values:
            symbol = point.symbol.underlying
            
            # Buy if the stock was mentioned more than 5 times in the WallStreetBets daily discussion, which translate into high popularity of rise
            if point.mentions > 5 and not self.portfolio[symbol].is_long:
                self.market_order(symbol, 1)
                
            # Otherwise, short sell
            elif point.mentions <= 5 and not self.portfolio[symbol].is_short:
                self.market_order(symbol, -1)

    def on_securities_changed(self, changes: SecurityChanges) -> None:
        for added in changes.added_securities:
            # Requesting wall street bet data to obtain the trader's insights
            quiver_wsb_symbol = self.add_data(QuiverWallStreetBets, added.symbol).symbol

            # Historical data
            history = self.history(QuiverWallStreetBets, quiver_wsb_symbol, 60, Resolution.DAILY)
            self.debug(f"We got {len(history)} items from our history request")

    def universe_selection(self, alt_coarse: List[QuiverWallStreetBetsUniverse]) -> List[Symbol]:
        for datum in alt_coarse:
            self.log(f"{datum.symbol},{datum.mentions},{datum.rank},{datum.sentiment}")
        
        # Select the ones with popularity (mentions) of better-than-others performance (rank)
        return [d.symbol for d in alt_coarse \
                    if d.mentions > 10 \
                    and d.rank < 100]

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class QuiverWallStreetBetsDataAlgorithm : QCAlgorithm
    {
        private Universe _universe;
        public override void Initialize()
        {
            SetStartDate(2019, 1, 1);
            SetEndDate(2020, 6, 1);
            SetCash(100000);

            UniverseSettings.Resolution = Resolution.Daily;
            // Filter using wall street bet insights
            _universe = AddUniverse<QuiverWallStreetBetsUniverse>(altCoarse =>
            {
                foreach (var datum in altCoarse.OfType<QuiverWallStreetBetsUniverse>())
                {
                    Log($"{datum.Symbol},{datum.Mentions},{datum.Rank},{datum.Sentiment}");
                }

                // Select the ones with popularity (mentions) of better-than-others performance (rank)
                return from d in altCoarse.OfType<QuiverWallStreetBetsUniverse>()
                       where d.Mentions > 10 && d.Rank < 100
                       select d.Symbol;
            });
        }

        public override void OnData(Slice slice)
        {
            var points = slice.Get<QuiverWallStreetBets>();
            foreach (var point in points.Values)
            {
                var symbol = point.Symbol.Underlying;
                
                // Buy if the stock was mentioned more than 5 times in the WallStreetBets daily discussion, which translate into high popularity of rise
                if (point.Mentions > 5 && !Portfolio[symbol].IsLong)
                {
                    MarketOrder(symbol, 1);
                }
                // Otherwise, short sell
                else if (point.Mentions <= 5 && !Portfolio[symbol].IsShort)
                {
                    MarketOrder(symbol, -1);
                }
            }
        }

        public override void OnSecuritiesChanged(SecurityChanges changes)
        {
            foreach(var added in changes.AddedSecurities)
            {
                // Requesting wall street bet data to obtain the trader's insights
                var quiverWSBSymbol = AddData<QuiverWallStreetBets>(added.Symbol).Symbol;

                // Historical data
                var history = History<QuiverWallStreetBets>(quiverWSBSymbol, 60, Resolution.Daily);
                Debug($"We got {history.Count()} items from our history request");
            }
        }
    }
}

from AlgorithmImports import *
from QuantConnect.DataSource import *

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

        self.universe_settings.resolution = Resolution.DAILY
        # Filter using wall street bet insights
        self._universe = self.add_universe(QuiverWallStreetBetsUniverse, self.universe_selection)
        
        self.add_alpha(WallStreamBetsAlphaModel())
        
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())
        
        self.add_risk_management(NullRiskManagementModel())
        
        self.set_execution(ImmediateExecutionModel())

    def universe_selection(self, alt_coarse: List[QuiverWallStreetBetsUniverse]) -> List[Symbol]:
        for datum in alt_coarse:
            self.log(f"{datum.symbol},{datum.mentions},{datum.rank},{datum.sentiment}")
        
        # Select the ones with popularity (mentions) of better-than-others performance (rank)
        return [d.symbol for d in alt_coarse
                    if d.mentions > 10                     and d.rank < 100]

class WallStreamBetsAlphaModel(AlphaModel):
    
    symbol_data_by_symbol = {}
    
    def __init__(self, mentions_threshold: int = 5) -> None:
        self.mentions_threshold = mentions_threshold
    
    def update(self, algorithm: QCAlgorithm, slice: Slice) -> List[Insight]:
        insights = []
        
        points = slice.Get(QuiverWallStreetBets)
        for point in points.Values:
            # Buy if the stock was mentioned more than 5 times in the WallStreetBets daily discussion, which translate into high popularity of rise
            # Otherwise short sell
            target_direction = InsightDirection.UP if point.mentions > self.mentions_threshold else InsightDirection.DOWN
            self.symbol_data_by_symbol[point.symbol.underlying].target_direction = target_direction
            
        for symbol, symbol_data in self.symbol_data_by_symbol.items():
            # Ensure we have security data for the current Slice to avoid stale fill
            if not (slice.contains_key(symbol) and slice[symbol] is not None):
                continue
            
            if symbol_data.target_direction is not None:
                insights += [Insight.price(symbol, timedelta(1), symbol_data.target_direction)]
                symbol_data.target_direction = None

        return insights
        
        
    def on_securities_changed(self, algorithm: QCAlgorithm, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            symbol = security.symbol
            self.symbol_data_by_symbol[symbol] = SymbolData(algorithm, symbol)
        
        for security in changes.removed_securities:
            symbol_data = self.symbol_data_by_symbol.pop(security.symbol, None)
            if symbol_data:
                symbol_data.dispose()
                
                
class SymbolData:
    target_direction = None
    
    def __init__(self, algorithm: QCAlgorithm, symbol: Symbol) -> None:
        self.algorithm = algorithm
        
        # Requesting wall street bet data to obtain the trader's insights
        self.quiver_wsb_symbol = algorithm.add_data(QuiverWallStreetBets, symbol).symbol
        
        # Historical data
        history = algorithm.history(self.quiver_wsb_symbol, 60, Resolution.DAILY)
        algorithm.debug(f"We got {len(history)} items from our history request for {symbol} Quiver WallStreetBets data")
        
    def dispose(self) -> None:
        # Unsubscribe from the Quiver WallStreetBets feed for this security to release computationa resources
        self.algorithm.remove_security(self.quiver_wsb_symbol)

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class QuiverWallStreetBetsDataAlgorithm : QCAlgorithm
    {
        private Universe _universe;
        public override void Initialize()
        {
            SetStartDate(2019, 1, 1);
            SetEndDate(2020, 6, 1);
            SetCash(100000);

            UniverseSettings.Resolution = Resolution.Daily;
            // Filter using wall street bet insights
            _universe = AddUniverse<QuiverWallStreetBetsUniverse>(altCoarse =>
            {
                foreach (var datum in altCoarse.OfType<QuiverWallStreetBetsUniverse>())
                {
                    Log($"{datum.Symbol},{datum.Mentions},{datum.Rank},{datum.Sentiment}");
                }

                // Select the ones with popularity (mentions) of better-than-others performance (rank)
                return from d in altCoarse.OfType<QuiverWallStreetBetsUniverse>()
                       where d.Mentions > 10 && d.Rank > 10
                       select d.Symbol;
            });

            AddAlpha(new WallStreamBetsAlphaModel());
            
            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
            
            AddRiskManagement(new NullRiskManagementModel());
            
            SetExecution(new ImmediateExecutionModel());
        }
    }

    public class WallStreamBetsAlphaModel : AlphaModel
    {
        private Dictionary<Symbol, SymbolData> _symbolDataBySymbol = new Dictionary<Symbol, SymbolData>();
        private int _mentionsThreshold;
        
        public WallStreamBetsAlphaModel(int mentionsThreshold=5)
        {
            _mentionsThreshold = mentionsThreshold;
        }

        public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice slice)
        {
            var insights = new List<Insight>();
            
            var points = slice.Get<QuiverWallStreetBets>();
            foreach (var point in points.Values)
            {
                // Buy if the stock was mentioned more than 5 times in the WallStreetBets daily discussion, which translate into high popularity of rise
                // Otherwise short sell
                var targetDirection = point.Mentions > _mentionsThreshold ? InsightDirection.Up : InsightDirection.Down;
                _symbolDataBySymbol[point.Symbol.Underlying].targetDirection = targetDirection;
            }
            
            foreach (var kvp in _symbolDataBySymbol)
            {
                var symbol = kvp.Key;
                var symbolData = kvp.Value;
                
                // Ensure we have security data for the current Slice to avoid stale fill
                if (!(slice.ContainsKey(symbol) && slice[symbol] != null))
                {
                    continue;
                }
                
                if (symbolData.targetDirection != null)
                {
                    insights.Add(Insight.Price(symbol, TimeSpan.FromDays(1), (InsightDirection)symbolData.targetDirection));
                    symbolData.targetDirection = null;
                }
            }
            return insights;
        }

        public override void OnSecuritiesChanged(QCAlgorithm algorithm, SecurityChanges changes)
        {
            foreach (var security in changes.AddedSecurities)
            {
                var symbol = security.Symbol;
                _symbolDataBySymbol.Add(symbol, new SymbolData(algorithm, symbol));
            }

            foreach (var security in changes.RemovedSecurities)
            {
                var symbol = security.Symbol;
                if (_symbolDataBySymbol.ContainsKey(symbol))
                {
                    _symbolDataBySymbol[symbol].dispose();
                    _symbolDataBySymbol.Remove(symbol);
                }
            }
        }
    }
    
    public class SymbolData
    {
        private Symbol _quiverWSBSymbol;
        private QCAlgorithm _algorithm;
        public InsightDirection? targetDirection = null;
        
        public SymbolData(QCAlgorithm algorithm, Symbol symbol)
        {
            _algorithm = algorithm;
            
            // Requesting wall street bet data to obtain the trader's insights
            _quiverWSBSymbol = algorithm.AddData<QuiverWallStreetBets>(symbol).Symbol;
            
            // Historical data
            var history = algorithm.History<QuiverWallStreetBets>(_quiverWSBSymbol, 60, Resolution.Daily);
            algorithm.Debug($"We got {history.Count()} items from our history request for {symbol} Quiver WallStreetBets data");
        }
        
        public void dispose()
        {
            // Unsubscribe from the Quiver WallStreetBets feed for this security to release computationa resources
            _algorithm.RemoveSecurity(_quiverWSBSymbol);
        }
    }
}

#r "../QuantConnect.DataSource.QuiverWallStreetBets.dll"
using QuantConnect.DataSource;

var qb = new QuantBook();

// Requesting data
var aapl = qb.AddEquity("AAPL", Resolution.Daily).Symbol;
var symbol = qb.AddData<QuiverWallStreetBets>(aapl).Symbol;

// Historical data
var history = qb.History<QuiverWallStreetBets>(symbol, 60, Resolution.Daily);
foreach (var bet in history.OfType<QuiverWallStreetBets>())
{
    Console.WriteLine($"{bet.Symbol} rank at {bet.EndTime}: {bet.Rank}");
}

// Add Universe Selection
IEnumerable<Symbol> UniverseSelection(IEnumerable<BaseData> altCoarse)
{
    return from d in altCoarse.OfType<QuiverWallStreetBetsUniverse>()
        where d.Mentions > 10 && d.Rank < 100 select d.Symbol;
}
var universe = qb.AddUniverse<QuiverWallStreetBetsUniverse>(UniverseSelection);

// Historical Universe data
var universeHistory = qb.UniverseHistory(universe, qb.Time.AddDays(-60), qb.Time);
foreach (var bets in universeHistory)
{
    foreach (QuiverWallStreetBetsUniverse bet in bets)
    {
        Console.WriteLine($"{bet.Symbol} rank at {bet.EndTime}: {bet.Rank}");
    }
}

qb = QuantBook()

# Requesting data
aapl = qb.add_equity("AAPL", Resolution.DAILY).symbol
symbol = qb.add_data(QuiverWallStreetBets, aapl).symbol

# Historical data
history = qb.history(QuiverWallStreetBets, symbol, 60, Resolution.DAILY)
for (symbol, time), bet in history.iterrows():
    print(f"{symbol} rank at {time}: {bet['rank']}")

# Add Universe Selection
def universe_selection(alt_coarse: List[QuiverWallStreetBetsUniverse]) -> List[Symbol]:
    return [d.symbol for d in alt_coarse if d.mentions > 10 and d.rank < 100]

universe = qb.add_universe(QuiverWallStreetBetsUniverse, universe_selection)
        
# Historical Universe data
universe_history = qb.universe_history(universe, qb.time-timedelta(60), qb.time)
for (univere_symbol, time), bets in universe_history.items():
    for bet in bets:
        print(f"{bet.symbol} rank at {bet.end_time}: {bet.rank}")