from AlgorithmImports import *
from QuantConnect.DataSource import *

class BrainCompanyFilingNLPDataAlgorithm(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2010, 1, 1)
        self.set_end_date(2021, 7, 8)
        self.set_cash(100000) 
        
        # Requesting data -- we aim to obtain a sentiment score from the company filings
        # Combining both fundamental and sentiment factor, as well as past performance and future provision
        self.aapl = self.add_equity("AAPL", Resolution.DAILY).symbol
        self.dataset_symbol = self.add_data(BrainCompanyFilingLanguageMetrics10K , self.aapl).symbol
        
        # Historical data
        history = self.history(self.dataset_symbol, 365, Resolution.DAILY)
        self.debug(f"We got {len(history)} items from our history request for {self.dataset_symbol}")
        
        
    def on_data(self, data):
        # Trade base on the updated report sentiment
        if data.contains_key(self.dataset_symbol):
            sentiment = data[self.dataset_symbol].report_sentiment.sentiment
            # Buy for a positive sentiment score for the positive return projection
            self.set_holdings(self.symbol, int(sentiment > 0))

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class BrainCompanyFilingNLPDataAlgorithm : QCAlgorithm
    {
        private Symbol _symbol;
        private Symbol _datasetSymbol;
        
        public override void Initialize()
        {
            SetStartDate(2010, 1, 1);
            SetEndDate(2021, 7, 8);
            SetCash(100000);
            
            // Requesting data -- we aim to obtain a sentiment score from the company filings
            // Combining both fundamental and sentiment factor, as well as past performance and future provision
            _symbol = AddEquity("AAPL", Resolution.Daily).Symbol;
            _datasetSymbol = AddData<BrainCompanyFilingLanguageMetrics10K>(_symbol).Symbol;
            
            // Historical data
            var history = History<BrainCompanyFilingLanguageMetrics10K>(_datasetSymbol, 365, Resolution.Daily);
            Debug($"We got {history.Count()} items from our history request for {_datasetSymbol}");
        }

        public override void OnData(Slice slice)
        {
            // Trade base on the updated report sentiment
            if (slice.ContainsKey(_datasetSymbol))
            {
                // Buy for a positive sentiment score for the positive return projection
                var sentiment = slice[_datasetSymbol].ReportSentiment.Sentiment;
                SetHoldings(_symbol, sentiment > 0 ? 1 : 0);
            }
        }
    }
}

from AlgorithmImports import *
from QuantConnect.DataSource import *

class BrainCompanyFilingNLPDataAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2010, 1, 1)
        self.set_end_date(2021, 7, 8)
        self.set_cash(100000) 
        
        self.universe_settings.resolution = Resolution.DAILY
        # Filter based on company filing data
        self.add_universe(BrainCompanyFilingLanguageMetricsUniverse10K, self.universe_selection)
        
        self.add_alpha(BrainCompanyFilingNLPAlphaModel())
        
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())
         
        self.add_risk_management(NullRiskManagementModel())
        
        self.set_execution(ImmediateExecutionModel())

    def universe_selection(self, alt_coarse: List[BrainCompanyFilingLanguageMetricsUniverse10K]) -> List[Symbol]:
        # Filter for the stocks with positive sentiment score for the positive return projection
        # Combining both fundamental and sentiment factor, as well as past performance and future provision
        return [d.symbol for d in alt_coarse \
                if d.report_sentiment.sentiment is not None and d.report_sentiment.sentiment > 0]
        
class BrainCompanyFilingNLPAlphaModel(AlphaModel):
    
    def update(self, algorithm: QCAlgorithm, slice: Slice):
        insights = []

        # Signal to invest in the selected universe, which are expected to have a positive return due to positive fundamentals and future prospect
        for symbol in algorithm.active_securities.keys:
            if not slice.contains_key(symbol):
                continue
            insights.append(Insight.price(symbol, timedelta(days=1), InsightDirection.UP))
        
        return insights

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class BrainCompanyFilingNLPDataAlgorithm : QCAlgorithm
    {
        public override void Initialize()
        {
            SetStartDate(2010, 1, 1);
            SetEndDate(2021, 7, 8);
            SetCash(100000);
            
            // Filter based on company filing data
            UniverseSettings.Resolution = Resolution.Daily;
            AddUniverse<BrainCompanyFilingLanguageMetricsUniverse10K>(altCoarse =>
            {
                // Filter for the stocks with positive sentiment score for the positive return projection
                // Combining both fundamental and sentiment factor, as well as past performance and future provision
                return from d in altCoarse.OfType<BrainCompanyFilingLanguageMetricsUniverse10K>() 
                    where d.ReportSentiment.Sentiment > 0m
                    select d.Symbol;
            });
            
            AddAlpha(new BrainCompanyFilingNLPAlphaModel());
            
            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
            
            AddRiskManagement(new NullRiskManagementModel());
            
            SetExecution(new ImmediateExecutionModel());
        }
    }
        
    public class BrainCompanyFilingNLPAlphaModel : AlphaModel
    {
        public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice slice)
        {
            var insights = new List<Insight>();
            
            // Signal to invest in the selected universe, which are expected to have a positive return due to positive fundamentals and future prospect
            foreach (var symbol in algorithm.ActiveSecurities.Keys)
            {
                if (!slice.ContainsKey(symbol))
                {
                    continue;
                }
                insights.Add(Insight.Price(symbol, TimeSpan.FromDays(1), InsightDirection.Up));
            }
            return insights;
        }
    }
}

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

var qb = new QuantBook();

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

// Historical data
var history = qb.History<BrainCompanyFilingLanguageMetrics10K>(symbol, 180, Resolution.Daily);
foreach (BrainCompanyFilingLanguageMetrics10K languageMetrics in history)
{
    Console.WriteLine($"{languageMetrics} at {languageMetrics.EndTime}");
}

// Add Universe Selection
IEnumerable<Symbol> UniverseSelection(IEnumerable<BaseData> altCoarse)
{
    var symbols = (from d in altCoarse.OfType<BrainCompanyFilingLanguageMetricsUniverse10K>()
        orderby d.ReportSentiment.Sentiment descending select d.Symbol).Take(10);
    return symbols;
}
var universe = qb.AddUniverse<BrainCompanyFilingLanguageMetricsUniverse10K>(UniverseSelection);

// Historical Universe data
var universeHistory = qb.UniverseHistory(universe, qb.Time.AddDays(-10), qb.Time);
foreach (var universeDay in universeHistory)
{
    foreach (BrainCompanyFilingLanguageMetricsUniverse10K languageMetrics in universeDay)
    {
        Console.WriteLine($"{languageMetrics.Symbol} sentiment at {languageMetrics.EndTime}: {languageMetrics.ReportSentiment.Sentiment}");
    }
}

qb = QuantBook()

# Requesting Data
aapl = qb.AddEquity("AAPL", Resolution.Daily).Symbol
symbol = qb.AddData(BrainCompanyFilingLanguageMetrics10K, aapl).Symbol

# Historical data
history = qb.History(BrainCompanyFilingLanguageMetrics10K, symbol, 180, Resolution.Daily)
for (symbol, time), row in history.iterrows():
    print(f"{symbol} sentiment at {time}: {row['reportsentiment'].Sentiment}")

# Add Universe Selection
def UniverseSelection(alt_coarse: List[BrainCompanyFilingLanguageMetricsUniverse10K]) -> List[Symbol]:
    return [d.Symbol for d in sorted([x for x in alt_coarse if x.ReportSentiment.Sentiment],
        key=lambda x: x.ReportSentiment.Sentiment, reverse=True)[:10]]

universe = qb.AddUniverse(BrainCompanyFilingLanguageMetricsUniverse10K, UniverseSelection)

# Historical Universe data
universe_history = qb.UniverseHistory(universe, qb.Time-timedelta(10), qb.Time)
for (_, time), universeDay in universe_history.items():
    for language_metrics in universeDay:
        print(f"{language_metrics.Symbol} sentiment at {language_metrics.EndTime}: {language_metrics.ReportSentiment.Sentiment}")