Brain

from AlgorithmImports import *


class BrainSentimentDataAlgorithm(QCAlgorithm):
    
    latest_sentiment_value = None
    target_holdings = 0
    
    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        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)

public class BrainSentimentDataAlgorithm : QCAlgorithm
{
    private Symbol _symbol;
    private Symbol _datasetSymbol;
    private decimal? _latestSentimentValue = null;
    private int _targetHoldings = 0;
    
    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        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 != null)
        {
            _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.Bars.ContainsKey(_symbol) && _targetHoldings == 1 != Portfolio.Invested)
        {
            SetHoldings(_symbol, _targetHoldings);
        }
    }
}

from AlgorithmImports import *


class BrainSentimentDataAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        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)
        if history.empty or 'sentiment' not in history.columns:
            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

public class BrainSentimentDataAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        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] != null)
            {
                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] != null))
            {
                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 = null;

    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);
        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 != null)
        {
            targetDirection = sentiment > _latestSentimentValue ? InsightDirection.Up : InsightDirection.Flat;
        }
        _latestSentimentValue = sentiment;
    }
}