US Equity

public class USEquityCorporateFundamentalsExampleAlgorithm : QCAlgorithm
{
    private Equity _aapl;
    // Add a member to track the last financial statement filing date.
    private DateTime? _lastFilingDate = null;
    private DateTime _exitTime;

    public override void Initialize()
    {
        // Add Equity data.
        _aapl = AddEquity("AAPL");
    }

    public override void OnData(Slice slice)
    {
        // Get the most recent filing date.
        var lastFilingDate = _aapl.Fundamentals.FinancialStatements.FileDate.Value;

        // When new financial statements are released, buy AAPL.
        if (_lastFilingDate.HasValue && lastFilingDate != _lastFilingDate.Value)
        {
            SetHoldings(_aapl.Symbol, 1);
            _exitTime = Time.AddDays(7);
        }

        // Liquidate the position after 1 week.
        if (_aapl.Holdings.Invested && Time >= _exitTime)
        {
            Liquidate();
        }
    
        // Update the last filing date to identify future changes.
        _lastFilingDate = lastFilingDate;
    }
}

class USEquityCorporateFundamentalsExampleAlgorithm(QCAlgorithm):
        
    def initialize(self) -> None:
        # Add Equity data.
        self._aapl = self.add_equity("AAPL")
        # Add a member to track the last financial statement filing date.
        self._last_filing_date = None

    def on_data(self, slice: Slice) -> None:
        # Get the most recent filing date.
        last_filing_date = self._aapl.fundamentals.financial_statements.file_date.value
        
        # When new financial statements are released, buy AAPL.
        if self._last_filing_date and last_filing_date != self._last_filing_date:
            self.set_holdings(self._aapl.symbol, 1)
            self._exit_time = self.time + timedelta(7)

        # Liquidate the position after 1 week.
        if self._aapl.holdings.invested and self.time >= self._exit_time:
            self.liquidate()
        
        # Update the last filing date to identify future changes.
        self._last_filing_date = last_filing_date

public class USEquityCorporateFundamentalsExampleAlgorithm : QCAlgorithm
{
    private Universe _universe;
    
    public override void Initialize()
    {
        SetCash(10_000_000);
        // Define the universe settings.
        var spy = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);
        UniverseSettings.Resolution = Resolution.Daily;
        UniverseSettings.Schedule.On(DateRules.MonthStart(spy));
        // Add a universe of the 500 largest Equities.
        _universe = AddUniverse(coarse => coarse
            .OrderByDescending(x => x.MarketCap)
            .Take(500)
            .Select(x => x.Symbol)
        );
        // Create a Scheduled Event to rebalance the portfolio each month.
        Schedule.On(DateRules.MonthStart(spy, 1), TimeRules.Midnight, Rebalance);
    }

    private void Rebalance()
    {
        // Wait until there are assets in the universe.
        if (_universe.Selected == null)
        {
            return;
        }
        // Group the universe constituents by sector.
        var symbolsBySector = new Dictionary<int, List<Symbol>>();
        foreach (var symbol in _universe.Selected)
        {
            var equity = Securities[symbol];
            if (equity.Price == 0)
            {
                continue;
            }
            var sectorCode = equity.Fundamentals.AssetClassification.MorningstarSectorCode;
            if (!symbolsBySector.ContainsKey(sectorCode))
            {
                symbolsBySector[sectorCode] = new List<Symbol>();
            }
            symbolsBySector[sectorCode].Add(symbol);
        }

        // Create targets to invest equally in each sector and invest equally in the assets within each sector.
        var targets = new List<PortfolioTarget>();
        var sectorCount = symbolsBySector.Count;
        foreach (var symbols in symbolsBySector.Values)
        {
            var weight = 1m / sectorCount / symbols.Count;
            targets.AddRange(symbols.Select(symbol => new PortfolioTarget(symbol, weight)));
        }

        // Place the trades.
        SetHoldings(targets, true);
    }
}

class USEquityCorporateFundamentalsExampleAlgorithm(QCAlgorithm):
        
    def initialize(self) -> None:
        self.set_cash(10_000_000)
        # Define the universe settings.
        spy = Symbol.create('SPY', SecurityType.EQUITY, Market.USA)
        self.universe_settings.resolution = Resolution.DAILY
        self.universe_settings.schedule.on(self.date_rules.month_start(spy))
        # Add a universe of the 500 largest Equities.
        self._universe = self.add_universe(
            lambda fundamental: [
                f.symbol for f in sorted(fundamental, key=lambda f: f.market_cap)[-500:]
            ]
        )
        # Create a Scheduled Event to rebalance the portfolio each month.
        self.schedule.on(self.date_rules.month_start(spy, 1), self.time_rules.midnight, self._rebalance)

    def _rebalance(self) -> None:
        # Wait until there are asset in the universe.
        if not self._universe.selected:
            return

        # Group the universe constituents by sector.
        symbols_by_sector = {}
        for symbol in self._universe.selected:
            equity = self.securities[symbol]
            if not equity.price:
                continue
            sector_code = equity.fundamentals.asset_classification.morningstar_sector_code
            if sector_code not in symbols_by_sector:
                symbols_by_sector[sector_code] = []
            symbols_by_sector[sector_code].append(symbol)
        
        # Create targets to invest equally in each sector and invest equally in the assets within each sector.
        targets = []
        sector_count = len(symbols_by_sector)
        for symbols in symbols_by_sector.values():
            weight = 1 / sector_count / len(symbols)
            targets.extend([PortfolioTarget(symbol, weight) for symbol in symbols])

        # Place the trades.
        self.set_holdings(targets, True)