Securities and Exchange Commission

from AlgorithmImports import *


class SECReport8KAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        self.set_cash(100000)
        # Seed the price of each asset with its last known price to avoid trading errors.
        self.set_security_initializer(
            BrokerageModelSecurityInitializer(
                self.brokerage_model, 
                FuncSecuritySeeder(self.get_last_known_prices)
            )
        )
        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)

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(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        SetCash(100000);
        // Seed the price of each asset with its last known price to avoid trading errors.
        SetSecurityInitializer(
            new BrokerageModelSecurityInitializer(BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices))
        );
        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 *


class SECReport8KAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        self.set_cash(100000)
        # Seed the price of each asset with its last known price to avoid trading errors.
        self.set_security_initializer(
            BrokerageModelSecurityInitializer(
                self.brokerage_model, 
                FuncSecuritySeeder(self.get_last_known_prices)
            )
        )
        self.universe_settings.resolution = Resolution.DAILY
        # Filter for the most liquid stocks for trading due to high market activities for efficient pricing from fundamental factor
        self.add_universe_selection(MostLiquidFundamentalUniverseSelectionModel())
        # 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(FundamentalUniverseSelectionModel):

    def select(self, algorithm: QCAlgorithm, fundamental: List[Fundamental]) -> List[Symbol]:
        # Select the top 10 traded companies with fundamental data, since the market activities can better reflect the fundamental factor efficiently
        sorted_by_dollar_volume = sorted(fundamental, key=lambda f: f.dollar_volume, reverse=True)
        return [f.symbol for f 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)

public class SECReport8KAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        SetCash(100000);
        // Seed the price of each asset with its last known price to avoid trading errors.
        SetSecurityInitializer(
            new BrokerageModelSecurityInitializer(BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices))
        );
        UniverseSettings.Resolution = Resolution.Daily;
        // Filter for the most liquid stocks for trading due to high market activities for efficient pricing from fundamental factor
        AddUniverseSelection(new MostLiquidFundamentalUniverseSelectionModel());
        // 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 : FundamentalUniverseSelectionModel
{
    public override IEnumerable<Symbol> Select(QCAlgorithm algorithm, IEnumerable<Fundamental> fundamental)
    {
        // Select the top 10 traded companies with fundamental data, since the market activities can better reflect the fundamental factor efficiently
        return fundamental
            .OrderByDescending(f => f.DollarVolume)
            .Take(10)
            .Select(f => f.Symbol);
    }
}

public class SECReport8KAlphaModel : AlphaModel
{
    private readonly Dictionary<Symbol, Symbol> _datasetSymbolBySymbol = [];

    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
            if (_datasetSymbolBySymbol.TryGetValue(symbol, out Symbol reportSymbol))
            {
                algorithm.RemoveSecurity(reportSymbol);
                _datasetSymbolBySymbol.Remove(symbol);
            }
        }
    }
}