class TiingoNewsDataAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2021, 6, 1)
        self.set_cash(100000)

        self.aapl = self.add_equity("AAPL", Resolution.MINUTE).symbol
        self.dataset_symbol = self.add_data(TiingoNews, self.aapl).symbol

namespace QuantConnect.Algorithm.CSharp.AltData
{
    public class TiingoNewsDataAlgorithm : QCAlgorithm
    {
        private Symbol _symbol, _datasetSymbol;

        public override void Initialize()
        {
            SetStartDate(2021, 1, 1);
            SetEndDate(2021, 6, 1);
            SetCash(100000);

            _symbol = AddEquity("AAPL", Resolution.Minute).Symbol;
            _datasetSymbol = AddData<TiingoNews>(_symbol).Symbol;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    if slice.contains_key(self.dataset_symbol):
        article = slice[self.dataset_symbol]
        self.log(f"{self.dataset_symbol} article description at {slice.time}: {article.description}")

public override void OnData(Slice slice)
{
    if (slice.ContainsKey(_datasetSymbol))
    {
        var article = slice[_datasetSymbol];
        Log($"{_datasetSymbol} article description at {slice.Time}: {article.Description}");
    }
}

def on_data(self, slice: Slice) -> None:
    for dataset_symbol, article in slice.get(TiingoNews).items():
        self.log(f"{dataset_symbol} article description at {slice.time}: {article.description}")

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Get<TiingoNews>())
    {
        var datasetSymbol = kvp.Key;
        var article = kvp.Value;
        Log($"{datasetSymbol} article description at {slice.Time}: {article.Description}");
    }
}

# DataFrame
history_df = self.history(self.dataset_symbol, 100, Resolution.DAILY)

# Dataset objects
self.history[TiingoNews](self.dataset_symbol, 100, Resolution.DAILY)

var history = History<TiingoNews>(_datasetSymbol, 100, Resolution.Daily);

self.remove_security(self.dataset_symbol)

RemoveSecurity(_datasetSymbol);

from AlgorithmImports import *
from QuantConnect.DataSource import *

class TiingoNewsDataAlgorithm(QCAlgorithm):

    current_holdings = 0
    target_holdings = 0
    # Custom word-score map to assign score for each word in article
    word_scores = {'good': 1, 'great': 1, 'best': 1, 'growth': 1,
                   'bad': -1, 'terrible': -1, 'worst': -1, 'loss': -1}

    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2021, 6, 1)
        self.set_cash(100000)
        
        # Requesting Tiingo news data to obtain the updated news articles to calculate the sentiment score
        self.aapl = self.add_equity("AAPL", Resolution.MINUTE).symbol
        self.tiingo_symbol = self.add_data(TiingoNews, self.aapl).symbol
        
        # Historical data
        history = self.history(self.tiingo_symbol, 14, Resolution.DAILY)
        self.debug(f"We got {len(history)} items from our history request")
        
        
    def on_data(self, slice: Slice) -> None:
        if slice.contains_key(self.tiingo_symbol):
            # Assign a sentiment score to the news article by the word-score map
            title_words = slice[self.tiingo_symbol].description.lower()
            score = 0
            for word, word_score in self.word_scores.items():
                if word in title_words:
                    score += word_score
            
            # Buy if aggregated sentiment score shows positive sentiment, sell vice versa
            if score > 0:
                self.target_holdings = 1
            elif score < 0:
                self.target_holdings = -1
        
        # Buy or short sell if the sentiment has changed from our current holdings
        if slice.contains_key(self.aapl) and self.current_holdings != self.target_holdings:
            self.set_holdings(self.aapl, self.target_holdings)
            self.current_holdings = self.target_holdings

using QuantConnect.DataSource;

namespace QuantConnect.Algorithm.CSharp.AltData
{
    public class TiingoNewsDataAlgorithm : QCAlgorithm
    {
        private Symbol _aapl;
        private Symbol _tiingoSymbol;
        private int _currentHoldings = 0;
        private int _targetHoldings = 0;
        // Custom word-score map to assign score for each word in article
        private Dictionary<string, int> _wordScores = new Dictionary<string, int>(){
            {"good", 1}, {"great", 1}, {"best", 1}, {"growth", 1},
            {"bad", -1}, {"terrible", -1}, {"worst", -1}, {"loss", -1}
        };
        
        public override void Initialize()
        {
            SetStartDate(2021, 1, 1);
            SetEndDate(2021, 6, 1);
            SetCash(100000);
            
            // Requesting Tiingo news data to obtain the updated news articles to calculate the sentiment score
            _aapl = AddEquity("AAPL", Resolution.Minute).Symbol;
            _tiingoSymbol = AddData<TiingoNews>(_aapl).Symbol;
            
            // Historical data
            var history = History<TiingoNews>(_tiingoSymbol, 14, Resolution.Daily);
            Debug($"We got {history.Count()} items from our history request");
        }
        
        public override void OnData(Slice slice)
        {
            if (slice.ContainsKey(_tiingoSymbol))
            {
                // Assign a sentiment score to the news article
                var titleWords = slice[_tiingoSymbol].Description.ToLower();
                var score = 0;
                foreach (KeyValuePair<string, int> entry in _wordScores)
                {
                    if (titleWords.Contains(entry.Key))
                    {
                        score += entry.Value;
                    }
                }

                // Buy if aggregated sentiment score shows positive sentiment, sell vice versa
                if (score > 0)
                {
                    _targetHoldings = 1;
                }
                else if (score < 0)
                {
                    _targetHoldings = -1;
                }
            }
            
            // Buy or short sell if the sentiment has changed from our current holdings
            if (slice.ContainsKey(_aapl) && _currentHoldings != _targetHoldings)
            {
                SetHoldings(_aapl, _targetHoldings);
                _currentHoldings = _targetHoldings;
            }
        }
    }
}

from AlgorithmImports import *
from QuantConnect.DataSource import *

class TiingoNewsDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2021, 6, 1)
        self.set_cash(100000)
        
        symbols = [Symbol.create("AAPL", SecurityType.EQUITY, Market.USA)]
        self.add_universe_selection(ManualUniverseSelectionModel(symbols))
        self.add_alpha(TiingoNewsAlphaModel())
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())

 
class TiingoNewsAlphaModel(AlphaModel):
    
    current_holdings = 0
    target_holdings = 0
    # Custom word-score map to assign score for each word in article
    word_scores = {'good': 1, 'great': 1, 'best': 1, 'growth': 1,
                   'bad': -1, 'terrible': -1, 'worst': -1, 'loss': -1}
    
    def update(self, algorithm: QCAlgorithm, slice: Slice) -> List[Insight]:
        if slice.contains_key(self.tiingo_symbol):
            # Assign a sentiment score to the news article by the word-score map
            title_words = slice[self.tiingo_symbol].description.lower()
            score = 0
            for word, word_score in self.word_scores.items():
                if word in title_words:
                    score += word_score

            # Buy if aggregated sentiment score shows positive sentiment, sell vice versa
            if score > 0:
                self.target_holdings = 1
            elif score < 0:
                self.target_holdings = -1
        
        # Buy or short sell if the sentiment has changed from our current holdings
        if slice.contains_key(self.aapl) and self.current_holdings != self.target_holdings:
            self.current_holdings = self.target_holdings
            direction = InsightDirection.UP if self.target_holdings == 1 else InsightDirection.DOWN
            return [Insight.price(self.aapl, timedelta(days=14), direction)]
            
        return []
        
        
    def on_securities_changed(self, algorithm: QCAlgorithm, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            self.aapl = security.symbol
            
            # Requesting Tiingo news data to obtain the updated news articles to calculate the sentiment score
            self.tiingo_symbol = algorithm.add_data(TiingoNews, self.aapl).symbol
                
            # Historical data
            history = algorithm.history(self.tiingo_symbol, 14, Resolution.DAILY)
            algorithm.debug(f"We got {len(history)} items from our history request")

using QuantConnect.DataSource;

namespace QuantConnect.Algorithm.CSharp.AltData
{
    public class TiingoNewsDataAlgorithm : QCAlgorithm
    {

        public override void Initialize()
        {
            SetStartDate(2021, 1, 1);
            SetEndDate(2021, 6, 1);
            SetCash(100000);
            
            var symbols = new[] {QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA)};
            AddUniverseSelection(new ManualUniverseSelectionModel(symbols));
            AddAlpha(new TiingoNewsAlphaModel());
            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
        }
        
        public class TiingoNewsAlphaModel : AlphaModel
        {
            private Symbol _aapl;
            private Symbol _tiingoSymbol;
            private int _currentHoldings = 0;
            private int _targetHoldings = 0;
            // Custom word-score map to assign score for each word in article
            private Dictionary<string, int> _wordScores = new Dictionary<string, int>(){
                {"good", 1}, {"great", 1}, {"best", 1}, {"growth", 1},
                {"bad", -1}, {"terrible", -1}, {"worst", -1}, {"loss", -1}
            };
    
            public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice slice)
            {
                var insights = new List<Insight>();
                
                if (slice.ContainsKey(_tiingoSymbol))
                {
                    // Assign a sentiment score to the news article by the word-score map
                    var titleWords = slice[_tiingoSymbol].Description.ToLower();
                    var score = 0;
                    foreach (KeyValuePair<string, int> entry in _wordScores)
                    {
                        if (titleWords.Contains(entry.Key))
                        {
                            score += entry.Value;
                        }
                    }

                    // Buy if aggregated sentiment score shows positive sentiment, sell vice versa
                    if (score > 0)
                    {
                        _targetHoldings = 1;
                    }
                    else if (score < 0)
                    {
                        _targetHoldings = -1;
                    }
                }
                
                // Buy or short sell if the sentiment has changed from our current holdings
                if (slice.ContainsKey(_aapl) && _currentHoldings != _targetHoldings)
                {
                    _currentHoldings = _targetHoldings;
                    var direction = _targetHoldings == 1 ? InsightDirection.Up : InsightDirection.Down;
                    insights.Add(Insight.Price(_aapl, TimeSpan.FromDays(14), direction));
                }
                
                return insights;
            }
    
            public override void OnSecuritiesChanged(QCAlgorithm algorithm, SecurityChanges changes)
            {
                foreach (var security in changes.AddedSecurities)
                {
                    _aapl = security.Symbol;
                    
                    // Requesting Tiingo news data to obtain the updated news articles to calculate the sentiment score
                    _tiingoSymbol = algorithm.AddData<TiingoNews>(_aapl).Symbol;
            
                    // Historical data
                    var history = algorithm.History<TiingoNews>(_tiingoSymbol, 14, Resolution.Daily);
                    algorithm.Debug($"We got {history.Count()} items from our history request");
                }
            }
        }
    }
}