from AlgorithmImports import *
from QuantConnect.DataSource import *

class SECReport8KAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2019, 1, 1)
        self.set_end_date(2019, 12, 31)
        self.set_cash(100000)

        self.universe_settings.resolution = Resolution.DAILY
        self.add_universe(self.coarse_selector)
        self.dataset_symbol_by_symbol = {}
        self.long_symbols = []
        self.rebalance = False

        # Request underlying equity data.
        ibm = self.add_equity("IBM", Resolution.DAILY).symbol
        # Add news data for the underlying IBM asset for trade signal generation
        earnings_filing = self.add_data(SECReport10Q, ibm, Resolution.DAILY).symbol
        # Request 120 days of history with the SECReport10Q IBM custom data Symbol
        history = self.history(SECReport10Q, earnings_filing, 120, Resolution.DAILY)
        self.debug(f"We got {len(history)} items from our history request")

    def coarse_selector(self, coarse: List[CoarseFundamental]) -> List[Symbol]:
        # Select the top 10 traded companies with fundamental data, since the market activities can better reflect the fundamental factor efficiently
        coarse = sorted([cf for cf in coarse if cf.has_fundamental_data],
            key=lambda cf: cf.dollar_volume, reverse=True)[:10]
        return [cf.symbol for cf in coarse]

    def on_data(self, slice: Slice) -> None:
        # Trade from SEC data 
        for report in slice.Get(SECReport8K).Values:
            underlying_symbol = report.symbol.underlying
            # Skip the Symbol if it's no longer in the universe (insuffucient popularity to reach market efficiency of fundamental factor)
            if underlying_symbol not in self.dataset_symbol_by_symbol:
                if underlying_symbol in self.long_symbols:
                    self.rebalance = True
                    self.long_symbols.remove(underlying_symbol)
                continue

            # Long the stocks with SEC report over 20000 text length, suggesting excessive insights or future projections are highlighted
            report_text_length = sum([len(i.text) for i in report.report.documents])
            if report_text_length > 20000:
                if underlying_symbol not in self.long_symbols:
                    self.rebalance = True
                    self.long_symbols.append(underlying_symbol)
            elif underlying_symbol in self.long_symbols:
                self.rebalance = True
                self.long_symbols.remove(underlying_symbol)

        if not self.rebalance:
            return
        self.rebalance = False

        # Invest equally to evenly dissipate the capital concentration risk
        portfolio_targets = []
        equal_weighting = 1 / len(self.long_symbols) if len(self.long_symbols) > 0 else 0
        for symbol, security_holding in self.portfolio.items():
            weight = 0
            if symbol in self.long_symbols:
                weight = equal_weighting
            elif not security_holding.invested:
                continue
            portfolio_targets.append(PortfolioTarget(symbol, weight))
        self.set_holdings(portfolio_targets)


    def on_securities_changed(self, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            # If added to universe, adds SECReport8K for trade signal generation
            self.dataset_symbol_by_symbol[security.symbol] = self.add_data(SECReport8K, security.symbol).symbol

        for security in changes.removed_securities:
            # Remove SEC data subscription to release computation resources
            dataset_symbol = self.dataset_symbol_by_symbol.pop(security.symbol, None)
            if dataset_symbol:
                self.remove_security(dataset_symbol)

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class SECReport8KAlgorithm : QCAlgorithm
    {
        private Dictionary<Symbol, Symbol> _datasetSymbolBySymbol = new Dictionary<Symbol, Symbol>();
        private List<Symbol> _longSymbols = new List<Symbol>();
        private bool _rebalance = false;

        public override void Initialize()
        {
            SetStartDate(2019, 1, 1);
            SetEndDate(2019, 12, 31);
            SetCash(100000);

            UniverseSettings.Resolution = Resolution.Daily;
            AddUniverse(CoarseSelector);

            // Request underlying equity data.
            var ibm = AddEquity("IBM", Resolution.Daily).Symbol;
            // Add SEC report 10-Q data for the underlying IBM asset for trade signal generation
            var earningsFiling = AddData<SECReport10Q>(ibm, Resolution.Daily).Symbol;
            // Request 120 days of history with the SECReport10Q IBM custom data Symbol.
            var history = History<SECReport10Q>(earningsFiling, 120, Resolution.Daily);
            Debug($"We got {history.Count()} items from our history request");
        }

        public IEnumerable<Symbol> CoarseSelector(IEnumerable<CoarseFundamental> coarse)
        {
            // Select the top 10 traded companies with fundamental data, since the market activities can better reflect the fundamental factor efficiently
            return coarse.Where(x => x.HasFundamentalData)
                .OrderByDescending(x => x.DollarVolume)
                .Take(10).Select(x => x.Symbol);
        }

        public override void OnData(Slice slice)
        {
            // Trade from SEC data 
            foreach (var report in slice.Get<SECReport8K>().Values)
            {
                var underlyingSymbol = report.Symbol.Underlying;
                // Skip the Symbol if it's no longer in the universe (insuffucient popularity to reach market efficiency of fundamental factor)
                if (!_datasetSymbolBySymbol.ContainsKey(underlyingSymbol))
                {
                    if (_longSymbols.Contains(underlyingSymbol))
                    {
                        _rebalance = true;
                        _longSymbols.Remove(underlyingSymbol);
                    }
                    continue;
                }

                // Long the stocks with SEC report over 20000 text length, suggesting excessive insights or future projections are highlighted
                var reportTextLength = report.Report.Documents.Select(x => x.Text.Length).Sum();
                if (reportTextLength > 20000)
                {
                    if (!_longSymbols.Contains(underlyingSymbol))
                    {
                        _rebalance = true;
                        _longSymbols.Add(underlyingSymbol);
                    }
                }
                else if (_longSymbols.Contains(underlyingSymbol))
                {
                    _rebalance = true;
                    _longSymbols.Remove(underlyingSymbol);
                }
            }

            if (!_rebalance)
            {
                return;
            }
            _rebalance = false;

            // Invest equally to evenly dissipate the capital concentration risk
            var portfolioTargets = new List<PortfolioTarget>();
            var equalWeighting = _longSymbols.Count > 0 ? 1.0m / _longSymbols.Count : 0m;
            foreach (var kvp in Portfolio)
            {
                var symbol = kvp.Key;
                var securityHolding = kvp.Value;
                var weight = 0m;
                if (_longSymbols.Contains(symbol))
                {
                    weight = equalWeighting;
                }
                else if (!securityHolding.Invested)
                {
                    continue;
                }
                portfolioTargets.Add(new PortfolioTarget(symbol, weight));
            }
            SetHoldings(portfolioTargets);
        }

        public override void OnSecuritiesChanged(SecurityChanges changes)
        {
            foreach (var security in changes.AddedSecurities)
            {
                // If added to universe, adds SECReport8K for trade signal generation
                _datasetSymbolBySymbol[security.Symbol] = AddData<SECReport8K>(security.Symbol).Symbol;
            }

            foreach (var security in changes.RemovedSecurities)
            {                
                Symbol reportSymbol;
                if (_datasetSymbolBySymbol.TryGetValue(security.Symbol, out reportSymbol))
                {
                    // Remove SEC data subscription to release computation resources
                    RemoveSecurity(reportSymbol);
                    _datasetSymbolBySymbol.Remove(security.Symbol);
                }
            }
        }
    }
}

from AlgorithmImports import *
from QuantConnect.DataSource import *

class SECReport8KAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2019, 1, 1)
        self.set_end_date(2019, 12, 31)
        self.set_cash(100000)

        self.universe_settings.resolution = Resolution.DAILY
        # Filter for the most liquid stocks for trading due to high market activities for effecient pricing from fundamental factor
        self.add_universe_selection(MostLiquidFundamentalUniverseSelectionModel(self.universe_settings))
        # Custom alpha model that generates insights from SEC data
        self.add_alpha(SECReport8KAlphaModel())
        # Invest equally to evenly dissipate the capital concentration risk
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel(lambda time: None))


class MostLiquidFundamentalUniverseSelectionModel(CoarseFundamentalUniverseSelectionModel):
    def __init__(self, universe_settings: UniverseSettings) -> None:
        super().__init__(self.select_coarse, universe_settings)

    def select_coarse(self, coarse: List[CoarseFundamental]) -> List[Symbol]:
        # Select the top 10 traded companies with fundamental data, since the market activities can better reflect the fundamental factor efficiently
        selected = [c for c in coarse if c.has_fundamental_data]
        sorted_by_dollar_volume = sorted(selected, key=lambda c: c.dollar_volume, reverse=True)
        return [c.symbol for c in sorted_by_dollar_volume[:10]]


class SECReport8KAlphaModel(AlphaModel):
    dataset_symbol_by_symbol = {}
    
    def update(self, algorithm: QCAlgorithm, slice: Slice) -> List[Insight]:
        insights = []

        # Trade only based on SEC data 
        for report in slice.Get(SECReport8K).Values:
            underlying_symbol = report.symbol.underlying
            if underlying_symbol not in self.dataset_symbol_by_symbol:
                continue

            # Long the stocks with SEC report over 20000 text length, suggesting excessive insights or future projections are highlighted
            report_text_length = sum([len(i.text) for i in report.report.documents])

            if report_text_length > 20000:
                direction = InsightDirection.UP
            elif algorithm.portfolio[underlying_symbol].invested:
                direction = InsightDirection.FLAT
            else:
                continue
            insights.append(Insight.price(underlying_symbol, timedelta(days=30), direction))

        return insights

    def on_securities_changed(self, algorithm: QCAlgorithm, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            # If added to universe, adds SECReport8K for trade signal generation
            self.dataset_symbol_by_symbol[security.symbol] = algorithm.add_data(SECReport8K, security.symbol).symbol

        for security in changes.removed_securities:
            # Remove SEC data subscription to release computation resources
            symbol_data = self.dataset_symbol_by_symbol.pop(security.symbol, None)
            if symbol_data:
                algorithm.remove_security(symbol_data)

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class SECReport8KAlgorithm : QCAlgorithm
    {
        public override void Initialize()
        {
            SetStartDate(2019, 1, 1);
            SetEndDate(2019, 12, 31);
            SetCash(100000);

            UniverseSettings.Resolution = Resolution.Daily;
            // Filter for the most liquid stocks for trading due to high market activities for effecient pricing from fundamental factor
            AddUniverseSelection(new MostLiquidFundamentalUniverseSelectionModel(UniverseSettings));
            // Custom alpha model that generates insights from SEC data
            AddAlpha(new SECReport8KAlphaModel());
            // Invest equally to evenly dissipate the capital concentration risk
            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel(time => null));
        }
    }

    class MostLiquidFundamentalUniverseSelectionModel : CoarseFundamentalUniverseSelectionModel
    {
        public MostLiquidFundamentalUniverseSelectionModel(UniverseSettings universeSettings)
            : base(default(Func<IEnumerable<CoarseFundamental>, IEnumerable<Symbol>>), universeSettings)
        {
        }

        public override IEnumerable<Symbol> SelectCoarse(QCAlgorithm algorithm, IEnumerable<CoarseFundamental> coarse)
        {
            // Select the top 10 traded companies with fundamental data, since the market activities can better reflect the fundamental factor efficiently
            return coarse.Where(x => x.HasFundamentalData)
                .OrderByDescending(x => x.DollarVolume)
                .Take(10).Select(x => x.Symbol);
        }
    }

    public class SECReport8KAlphaModel : AlphaModel
    {
        private Dictionary<Symbol, Symbol> _datasetSymbolBySymbol = new Dictionary<Symbol, Symbol>();

        public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice slice)
        {
            var insights = new List<Insight>();

            // Trade only based on SEC data 
            foreach (var report in slice.Get<SECReport8K>().Values)
            {
                var underlyingSymbol = report.Symbol.Underlying;
                if (!_datasetSymbolBySymbol.ContainsKey(underlyingSymbol))
                {
                    continue;
                }

                // Long the stocks with SEC report over 20000 text length, suggesting excessive insights or future projections are highlighted
                var reportTextLength = report.Report.Documents.Select(x => x.Text.Length).Sum();
                InsightDirection direction;
                if (reportTextLength > 20000)
                {
                    direction = InsightDirection.Up;
                }
                else if (algorithm.Portfolio[underlyingSymbol].Invested)
                {
                    direction = InsightDirection.Flat;
                }
                else
                {
                    continue;
                }
                insights.Add(Insight.Price(underlyingSymbol, TimeSpan.FromDays(30), direction));
            }

            return insights;
        }

        public override void OnSecuritiesChanged(QCAlgorithm algorithm, SecurityChanges changes)
        {
            foreach (var symbol in changes.AddedSecurities.Select(x => x.Symbol))
            {
                // If added to universe, adds SECReport8K for trade signal generation
                _datasetSymbolBySymbol[symbol] = algorithm.AddData<SECReport8K>(symbol).Symbol;
            }
        	
            foreach (var symbol in changes.RemovedSecurities.Select(x => x.Symbol))
            {
                // Remove SEC data subscription to release computation resources
                Symbol reportSymbol;
                if (_datasetSymbolBySymbol.TryGetValue(symbol, out reportSymbol))
                {
                        algorithm.RemoveSecurity(reportSymbol);
                        _datasetSymbolBySymbol.Remove(symbol);
                }
            }
        }
    }
}