QuantConnect

from AlgorithmImports import *
from QuantConnect.DataSource import *

class IndexDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2021, 7, 8)
        self.set_cash(100000)

        # Request SPY data as a trading vehicle for SPX
        self.spy = self.add_equity("SPY").symbol

        # Request SPX data for trade signal generation
        spx = self.add_index("SPX").symbol

        # Create short and long-term EMA indicators for trend estimation to trade
        self.ema_fast = self.EMA(spx, 80, Resolution.DAILY)
        self.ema_slow = self.EMA(spx, 200, Resolution.DAILY)
        self.set_warm_up(200, Resolution.DAILY)

        # Historical data
        history = self.history(spx, 60, Resolution.DAILY)
        self.debug(f'We got {len(history.index)} items from our history request')

    def on_data(self, slice: Slice) -> None:
        # Trade signals required indicators to be ready
        if self.is_warming_up or not self.ema_slow.is_ready:
            return

        # If short-term EMA is above long-term, it indicates an up trend, so we buy SPY
        if not self.portfolio.invested and self.ema_fast > self.ema_slow:
            self.set_holdings(self.spy, 1)
        # If it is the reverse, it indicates a downtrend, and we liquidate any position
        elif self.ema_fast < self.ema_slow:
            self.liquidate()

public class IndexDataAlgorithm : QCAlgorithm
{
    private Symbol _spy;
    private ExponentialMovingAverage _emaSlow;
    private ExponentialMovingAverage _emaFast;

    public override void Initialize()
    {
        SetStartDate(2020, 1, 1);
        SetEndDate(2021, 7, 8);
        SetCash(1000000);

        // Request SPY data as trading vehicle for SPX
        _spy = AddEquity("SPY").Symbol;

        // Request SPX data for trade signal generation
        var spx = AddIndex("SPX").Symbol;

        // Create short and long-term EMA indicators for trend estimation to trade
        _emaFast = EMA(spx, 80, Resolution.Daily);
        _emaSlow = EMA(spx, 200, Resolution.Daily);
        SetWarmUp(200, Resolution.Daily);

        // Historical data
        var history = History(spx, 60, Resolution.Daily);
        Debug($"We got {history.Count()} items from our history request");
    }

    public override void OnData(Slice slice)
    {
        // Trade signals required indicators to be ready
        if (IsWarmingUp || !_emaSlow.IsReady)
        {
            return;
        }

        // If short-term EMA is above long-term, it indicates an up trend, so we buy SPY
        if (!Portfolio.Invested && _emaFast > _emaSlow)
        {
            SetHoldings(_spy, 1);
        }
        // If it is the reverse, it indicates a downtrend, and we liquidate any position
        else if (_emaFast < _emaSlow)
        {
            Liquidate();
        }
    }
}

from AlgorithmImports import *
from QuantConnect.DataSource import *

class IndexDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2021, 7, 8)
        self.set_cash(100000)

        # Universe contains only SPY as a trading vehicle for SPX
        self.set_universe_selection(ManualUniverseSelectionModel
        (
            Symbol.create("SPY", SecurityType.EQUITY, Market.USA)
        ))
        # Custom alpha model that emits insights based on SPX index data
        self.set_alpha(SpxEmaCrossAlphaModel(self))
        # Equally investing can dissipate non-systematic risky event's capital concentration risk evenly
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel(Expiry.END_OF_MONTH))
    
class SpxEmaCrossAlphaModel(AlphaModel):
    def __init__(self, algorithm: QCAlgorithm) -> None:
        # Request SPX data for trade signal generation
        spx = algorithm.add_index("SPX").symbol

        # Create short and long-term EMA indicators for trend estimation to trade
        self.ema_fast = algorithm.EMA(spx, 80, Resolution.DAILY)
        self.ema_slow = algorithm.EMA(spx, 200, Resolution.DAILY)
        algorithm.set_warm_up(200, Resolution.DAILY)

        # Historical data
        history = algorithm.history(spx, 60, Resolution.DAILY)
        algorithm.debug(f'We got {len(history.index)} items from our history request')
    
    def update(self, algorithm: QCAlgorithm, slice: Slice) -> List[Insight]:
        # Trade signals required indicators to be ready
        if algorithm.is_warming_up or not self.ema_slow.is_ready:
            return []

        # If short-term EMA is above long-term, it indicates an up trend, so we buy SPY
        if not algorithm.portfolio.invested and self.ema_fast > self.ema_slow:
            return [Insight.price(kvp.key, Expiry.END_OF_MONTH, InsightDirection.UP)
                for kvp in algorithm.active_securities if kvp.value.is_tradable]
        # If it is the reverse, it indicates downtrend, and we liquidate any position
        elif self.ema_fast < self.ema_slow:
            return [Insight.price(kvp.key, Expiry.END_OF_MONTH, InsightDirection.FLAT)
                for kvp in algorithm.active_securities if kvp.value.is_tradable]
            
        return []

public class IndexDataAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2020, 1, 1);
        SetEndDate(2021, 7, 8);
        SetCash(1000000);

        // Universe contains only SPY as a trading vehicle for SPX
        SetUniverseSelection(new ManualUniverseSelectionModel
        (
            QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA)
        ));
        // Custom alpha model that emits insights based on SPX index data
        SetAlpha(new SpxEmaCrossAlphaModel(this));
        // Equally invests can dissipate non-systematic risky event's capital concentration risk evenly
        SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel(Expiry.EndOfMonth));
    }
}

public class SpxEmaCrossAlphaModel : AlphaModel
{
    private ExponentialMovingAverage _emaSlow;
    private ExponentialMovingAverage _emaFast;

    public SpxEmaCrossAlphaModel(QCAlgorithm algorithm)
    {
        // Request SPX data for trade signal generation
        var spx = algorithm.AddIndex("SPX").Symbol;

        // Create short and long-term EMA indicators for trend estimation to trade
        _emaFast = algorithm.EMA(spx, 80, Resolution.Daily);
        _emaSlow = algorithm.EMA(spx, 200, Resolution.Daily);
        algorithm.SetWarmUp(200, Resolution.Daily);

        // Historical data
        var history = algorithm.History(spx, 60, Resolution.Daily);
        algorithm.Debug($"We got {history.Count()} items from our history request");
    }

    public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice slice)
    {
        // Trade signals required indicators to be ready
        if (algorithm.IsWarmingUp || !_emaSlow.IsReady)
        {
            return Enumerable.Empty<Insight>();
        }

        // If short-term EMA is above long-term, it indicates an up trend, so we buy SPY
        if (!algorithm.Portfolio.Invested && _emaFast > _emaSlow)
        {
            return algorithm.ActiveSecurities
                .Where(kvp => kvp.Value.IsTradable)
                .Select(kvp => Insight.Price(kvp.Key, Expiry.EndOfMonth, InsightDirection.Up));
        }
        // If it is the reverse, it indicates downtrend, and we liquidate any position
        else if (_emaFast < _emaSlow)
        {
            return algorithm.ActiveSecurities
                .Where(kvp => kvp.Value.IsTradable)
                .Select(kvp => Insight.Price(kvp.Key, Expiry.EndOfMonth, InsightDirection.Flat));
        }

        return Enumerable.Empty<Insight>();
    }
}