Brain

from AlgorithmImports import *
from QuantConnect.DataSource import *

class BrainSentimentDataAlgorithm(QCAlgorithm):
    
    latest_sentiment_value = None
    target_holdings = 0
    
    def initialize(self) -> None:
        self.set_start_date(2019, 1, 1)
        self.set_end_date(2021, 7, 8)
        self.set_cash(100000) 
        
        # Requesting the processed longer term (30-day) sentiment score data for sentiment trading
        self.aapl = self.add_equity("AAPL", Resolution.DAILY).symbol
        self.dataset_symbol = self.add_data(BrainSentimentIndicator30Day, self.aapl).symbol
        
        # Historical data
        history = self.history(self.dataset_symbol, 100, Resolution.DAILY)
        self.debug(f"We got {len(history)} items from our history request for {self.dataset_symbol}")
        if history.empty:
            return
        
        # Warm up historical sentiment values, cache for comparing last sentiment score to trade, making it immediately tradable signal
        previous_sentiment_values = history.loc[self.dataset_symbol].sentiment.values
        for sentiment in previous_sentiment_values:
            self.update(sentiment)
            
    def update(self, sentiment: float) -> None:
        # Comparing the last sentiment score and decide to buy if the sentiment increases to ride the popularity
        if self.latest_sentiment_value is not None:
            self.target_holdings = int(sentiment > self.latest_sentiment_value)
        self.latest_sentiment_value = sentiment
        
    def on_data(self, slice: Slice) -> None:
        # Update trade direction based on updated data
        if slice.contains_key(self.dataset_symbol):
            sentiment = slice[self.dataset_symbol].sentiment
            self.update(sentiment)
           
        # Ensure we have security data in the current slice to avoid stale fill
        if not (slice.contains_key(self.aapl) and slice[self.aapl] is not None):
            return
        
        # Buy if sentiment increase, liquidate otherwise to ride on the popularity of the equity
        if self.target_holdings != self.portfolio.invested:
            self.set_holdings(self.aapl, self.target_holdings)

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class BrainSentimentDataAlgorithm : QCAlgorithm
    {
        private Symbol _symbol;
        private Symbol _datasetSymbol;
        private decimal? _latestSentimentValue = None;
        private int _targetHoldings = 0;
        
        public override void Initialize()
        {
            SetStartDate(2019, 1, 1);
            SetEndDate(2021, 7, 8);
            SetCash(100000);
            
            // Requesting the processed longer term (30-day) sentiment score data for sentiment trading
            _symbol = AddEquity("AAPL", Resolution.Daily).Symbol;
            _datasetSymbol = AddData<BrainSentimentIndicator30Day>(_symbol).Symbol;
            
            // Historical data
            var history = History<BrainSentimentIndicator30Day>(_datasetSymbol, 100, Resolution.Daily);
            Debug($"We got {history.Count()} items from our history request for {_datasetSymbol}");
            
            // Warm up historical sentiment values, cache for comparing last sentiment score to trade, making it immediately tradable signal
            var previousSentimentValues = history.Select(x => x.Sentiment);
            foreach (var sentiment in previousSentimentValues)
            {
                Update(sentiment);
            }
        }

        
        public void Update(decimal sentiment)
        {
            // Comparing the last sentiment score and decide to buy if the sentiment increases to ride the popularity
            if (_latestSentimentValue != None)
            {
                _targetHoldings = sentiment > _latestSentimentValue ? 1 : 0;
            }
            _latestSentimentValue = sentiment;
        }
        
        public override void OnData(Slice slice)
        {
            // Update trade direction based on updated data
            if (slice.ContainsKey(_datasetSymbol))
            {
                var sentiment = slice[_datasetSymbol].Sentiment;
                Update(sentiment);
            }

            // Ensure we have security data in the current slice to avoid stale fill
            // Buy if sentiment increase, liquidate otherwise to ride on the popularity of the equity
            if (slice.Bar.ContainsKey(_symbol) && _targetHoldings == 1 != Portfolio.Invested)
            {
                SetHoldings(_symbol, _targetHoldings);
            }
        }
    }
}

from AlgorithmImports import *
from QuantConnect.DataSource import *

class BrainSentimentDataAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2019, 1, 1)
        self.set_end_date(2021, 7, 8)
        self.set_cash(100000) 
        
        self.settings.minimum_order_margin_portfolio_percentage = 0
        self.universe_settings.resolution = Resolution.DAILY
        # Filter base on sentiment data
        self.add_universe(BrainSentimentIndicatorUniverse, self.universe_selection)
        
        self.add_alpha(BrainSentimentAlphaModel())
        
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())
         
        self.add_risk_management(NullRiskManagementModel())
        
        self.set_execution(ImmediateExecutionModel())

    def universe_selection(self, alt_coarse: List[BrainSentimentIndicatorUniverse]) -> List[Symbol]:
        # Filter for any sentiment on last 7 days to trade on sentiment news
        return [d.symbol for d in alt_coarse \
        if d.SentimentalArticleMentions7Days is not None and d.SentimentalArticleMentions7Days > 0]

        
class BrainSentimentAlphaModel(AlphaModel):
    
    symbol_data_by_symbol = {}

    def update(self, algorithm: QCAlgorithm, slice: Slice) -> List[Insight]:
        insights = []
        
        for symbol, symbol_data in self.symbol_data_by_symbol.items():
            # Update trade direction based on updated data
            if slice.contains_key(symbol_data.dataset_symbol) and slice[symbol_data.dataset_symbol] is not None:
                sentiment = slice[symbol_data.dataset_symbol].sentiment
                symbol_data.update(sentiment)
               
            # Ensure we have security data in the current slice to avoid stale fill
            if not (slice.contains_key(symbol) and slice[symbol] is not None):
                continue

            # Buy if sentiment increase, liquidate otherwise to ride on the popularity of the equity
            if symbol_data.target_direction == InsightDirection.UP != algorithm.portfolio[symbol].invested:
                insights.append(Insight.price(symbol, timedelta(days=100), symbol_data.target_direction))
        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 = InsightDirection.FLAT
    _latest_sentiment_value = None
    
    def __init__(self, algorithm: QCAlgorithm, symbol: Symbol) -> None:
        self.algorithm = algorithm
        
        # Requesting the processed longer term (30-day) sentiment score data for sentiment trading
        self.dataset_symbol = algorithm.add_data(BrainSentimentIndicator30Day, symbol).symbol
        
        # Historical data
        history = algorithm.history(self.dataset_symbol, 100, Resolution.DAILY)
        algorithm.debug(f"We got {len(history)} items from our history request for {self.dataset_symbol}")
        if history.empty:
            return
        
        # Warm up historical sentiment values, cache for comparing last sentiment score to trade, making it immediately tradable signal
        previous_sentiment_values = history.loc[self.dataset_symbol].sentiment.values
        for sentiment in previous_sentiment_values:
            self.update(sentiment)
        
    def dispose(self) -> None:
        # Unsubscribe from the Brain Sentiment feed for this security to release computational resources
        self.algorithm.remove_security(self.dataset_symbol)
        
    def update(self, sentiment: float) -> None:
        # Comparing the last sentiment score and decide to buy if the sentiment increases to ride the popularity
        if self._latest_sentiment_value is not None:
            if sentiment > self._latest_sentiment_value:
                self.target_direction = InsightDirection.UP
            else:
                self.target_direction = InsightDirection.FLAT
        self._latest_sentiment_value = sentiment

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class BrainSentimentDataAlgorithm : QCAlgorithm
    {
        public override void Initialize()
        {
            SetStartDate(2019, 1, 1);
            SetEndDate(2021, 7, 8);
            SetCash(100000);
            
            Settings.MinimumOrderMarginPortfolioPercentage = 0;
            UniverseSettings.Resolution = Resolution.Daily;
            // Filter by sentiment data
            AddUniverse<BrainSentimentIndicatorUniverse>(altCoarse =>
            {
                // Filter for any sentiment on last 7 days to trade on sentiment news
                return from d in altCoarse.OfType<BrainSentimentIndicatorUniverse>()
                    where d.TotalArticleMentions7Days > 0m
                    select d.Symbol;
            });
            
            AddAlpha(new BrainSentimentAlphaModel());
            
            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
            
            AddRiskManagement(new NullRiskManagementModel());
            
            SetExecution(new ImmediateExecutionModel());
        }
    }
        
        
    public class BrainSentimentAlphaModel : AlphaModel
    {
        private Dictionary<Symbol, SymbolData> _symbolDataBySymbol = new Dictionary<Symbol, SymbolData>();

        public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice slice)
        {
            var insights = new List<Insight>();
            
            foreach (var entry in _symbolDataBySymbol)
            {
                var symbol = entry.Key;
                var symbolData = entry.Value;

                // Update trade direction based on updated data
                if (slice.ContainsKey(symbolData.datasetSymbol)  && slice[symbolData.datasetSymbol] != None)
                {
                    var sentiment = slice[symbolData.datasetSymbol].Sentiment;
                    symbolData.Update(sentiment);
                }
                
                // Ensure we have security data in the current slice to avoid stale fill
                if (!(slice.ContainsKey(symbol) && slice[symbol] != None))
                {
                    continue;
                }

                // Buy if sentiment increase, liquidate otherwise to ride on the popularity of the equity
                if (symbolData.targetDirection == InsightDirection.Up != algorithm.Portfolio[symbol].Invested)
                {
                    insights.Add(Insight.Price(symbol, TimeSpan.FromDays(365), symbolData.targetDirection));
                }
            }
            
            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
    {
        public Symbol datasetSymbol;
        public InsightDirection targetDirection = InsightDirection.Flat;
        private QCAlgorithm _algorithm;
        private decimal? _latestSentimentValue = None;

        public SymbolData(QCAlgorithm algorithm, Symbol symbol)
        {
            _algorithm = algorithm;
            
            // Requesting the processed longer term (30-day) sentiment score data for sentiment trading
            datasetSymbol = algorithm.AddData<BrainSentimentIndicator30Day>(symbol).Symbol;
            
            // Historical data
            var history = algorithm.History<BrainSentimentIndicator30Day>(datasetSymbol, 100, Resolution.Daily);
            algorithm.Debug($"We got {history.Count()} items from our history request for {symbol}");
            if (history.Count() == 0)
            {
                return;
            }
            
            // Warm up historical sentiment values, cache for comparing last sentiment score to trade, making it immediately tradable signal
            var previousSentimentValues = history.Select(x => x.Sentiment);
            foreach (var sentiment in previousSentimentValues)
            {
                Update(sentiment);
            }
        }
        
        public void dispose()
        {
            // Unsubscribe from the Brain Sentiment feed for this security to release computational resources
            _algorithm.RemoveSecurity(datasetSymbol);
        }
        
        public void Update(decimal sentiment)
        {
            // Comparing the last sentiment score and decide to buy if the sentiment increases to ride the popularity
            if (_latestSentimentValue != None)
            {
                targetDirection = sentiment > _latestSentimentValue ? InsightDirection.Up : InsightDirection.Flat;
            }
            _latestSentimentValue = sentiment;
        }
    }
}