class CashIndexAlgorithm(QCAlgorithm):

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

        self.vix = self.add_index("VIX").symbol

namespace QuantConnect
{
    public class CashIndexAlgorithm : QCAlgorithm
    {
        private Symbol _symbol;
        
        public override void Initialize()
        {
            SetStartDate(2020, 6, 1);
            SetEndDate(2021, 6, 1);
            SetCash(100000);
            
            _symbol = AddIndex("VIX").Symbol;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    if self.vix in slice.bars:
        trade_bar = slice.bars[self.vix]
        self.log(f"{self.vix} close at {slice.time}: {trade_bar.close}")

public override void OnData(Slice slice)
{
    if (slice.Bars.ContainsKey(_symbol))
    {
        var tradeBar = slice.Bars[_symbol];
        Log($"{_symbol} price at {slice.Time}: {tradeBar.Close}");
    }
}

def on_data(self, slice: Slice) -> None:
    for symbol, trade_bar in slice.bars.items():
        self.log(f"{symbol} close at {slice.time}: {trade_bar.close}")

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Bars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        Log($"{symbol} price at {slice.Time}: {tradeBar.Close}");
    }
}

# DataFrame
history_df = self.history(self.vix, 100, Resolution.DAILY)

# TradeBar objects
history_bars = self.history[TradeBar](self.vix, 100, Resolution.DAILY)

// TradeBar objects
var historyBars = History(_symbol, 100, Resolution.Daily);

self.remove_security(self.vix)

RemoveSecurity(_symbol);

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()

using QuantConnect.DataSource;

namespace QuantConnect
{
    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 []

using QuantConnect.DataSource;

namespace QuantConnect
{
    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>();
        }
    }
}