Greeks and Implied Volatility

public class AutomaticImpliedVolatilityIndicatorAlgorithm : QCAlgorithm
{
    private Future _future;
    private (Symbol option1, Symbol option2) _options;

    public override void Initialize()
    {
        SetStartDate(2024, 1, 1);
        SetEndDate(2024, 2, 1);
        // Subscribe to the underlying asset.
        _future = AddFuture(Futures.Indices.SP500EMini, 
            dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
            dataMappingMode: DataMappingMode.OpenInterest,
            contractDepthOffset: 0);
        _future.SetFilter(0, 182);
    
        // Set up a Scheduled Event to select contracts and create the indicators every day before market open.
        Schedule.On(
            DateRules.EveryDay(_future.Symbol),
            TimeRules.At(9, 0),
            UpdateContractsAndGreeks
        );
    }

    private void UpdateContractsAndGreeks()
    {
        if (_future.Mapped == null)
        {
            return;
        }
        // Get all the tradable Option contracts.
        var chain = OptionChain(_future.Mapped);
        
        // Filter the contracts down. For example, ATM contracts with atleast 1 month until expiry.
        var filteredChain = chain.Where(contract => contract.Expiry > Time.AddDays(30));
        if (filteredChain.Count() == 0)
        {
            return;
        }
        var expiry = filteredChain.Min(contract => contract.Expiry);
        filteredChain = filteredChain
            .Where(contract => contract.Expiry == expiry)
            .OrderBy(contract => Math.Abs(contract.Strike - contract.UnderlyingLastPrice))
            .Take(4);

        // Group the contracts into call/put pairs.
        foreach (var group in filteredChain.GroupBy(contract => contract.Strike))
        {
            var contracts = group.ToList();
            if (contracts.Count() > 1)
            {
                // Subscribe to both contracts.
                var contract1 = AddFutureOptionContract(contracts[0]) as dynamic;
                var contract2 = AddFutureOptionContract(contracts[1]) as dynamic;

                // Create and save the automatic ImpliedVolatility indicators.
                contract1.IV = IV(contracts[0], contracts[1]);
                contract2.IV = IV(contracts[1], contracts[0]);

                _options = (contracts[0], contracts[1]);
            }
        }
    }

    public override void OnData(Slice slice)
    {
        // Get the ImpliedVolatility indicator of each contract.
        foreach (var (canonical, chain) in slice.OptionChains)
        {
            foreach (var symbol in chain)
            {
                var option = Securities[symbol] as dynamic;
                var indicator = option.IV;
            }
        }

        // Sell straddle as an example to trade.
        if (!Portfolio.Invested && _options != default)
        {
            Sell(_options.option1, 1);
            Sell(_options.option2, 1);
        }
        // Liquidate any assigned positions.
        if (Portfolio[_future.Mapped].Invested)
        {
            Liquidate(_future.Mapped);
        }
    }
}

class AutomaticImpliedVolatilityIndicatorAlgorithm(QCAlgorithm):
    
    def initialize(self) -> None:
        self.set_start_date(2024, 1, 1)
        self.set_end_date(2024, 2, 1)
        # Subscribe to the underlying asset.
        self._future = self.add_future(
            Futures.Indices.SP_500_E_MINI,
            data_mapping_mode=DataMappingMode.OPEN_INTEREST,
            data_normalization_mode=DataNormalizationMode.BACKWARDS_RATIO,
            contract_depth_offset=0
        )
        self._future.set_filter(0, 182)

        # Set up a Scheduled Event to select contracts and create the indicators every day before market open.
        self.schedule.on(
            self.date_rules.every_day(self._future.symbol),
            self.time_rules.at(9, 0),
            self._update_contracts_and_greeks
        )
        
        self._options = None

    def _update_contracts_and_greeks(self) -> None:
        if self._future.mapped is None:
            return
        # Get all the tradable Option contracts.
        chain = self.option_chain(self._future.mapped, flatten=True).data_frame
        if chain.empty:
            return

        # Filter the contracts down. For example, ATM contracts with atleast 1 month until expiry.
        chain = chain[chain.expiry > self.time + timedelta(30)]
        expiry = chain.expiry.min()
        chain = chain[chain.expiry == expiry]
        chain.loc[:, 'abs_strike_delta'] = abs(chain['strike'] - chain['underlyinglastprice'])
        abs_strike_delta = chain['abs_strike_delta'].min()
        chain = chain[chain['abs_strike_delta'] == abs_strike_delta]

        # Group the contracts into call/put pairs.
        contracts_pair_sizes = chain.groupby(['expiry', 'strike']).count()['right']
        paired_contracts = contracts_pair_sizes[contracts_pair_sizes == 2].index
        expiries = [x[0] for x in paired_contracts]
        strikes = [x[1] for x in paired_contracts]
        symbols = [
            idx[-1] for idx in chain[
                chain['expiry'].isin(expiries) & chain['strike'].isin(strikes)
            ].reset_index().groupby(['expiry', 'strike', 'right', 'symbol']).first().index
        ]
        pairs = [(symbols[i], symbols[i+1]) for i in range(0, len(symbols), 2)]

        for call, put in pairs:
            # Subscribe to both contracts.
            contract1 = self.add_future_option_contract(call)
            contract2 = self.add_future_option_contract(put)
            
            # Create and save the automatic ImpliedVolatility indicators.
            contract1.iv = self.iv(call, put)
            contract2.iv = self.iv(put, call)

            self._options = (call, put)
        
    def on_data(self, slice: Slice) -> None:
        # Get the ImpliedVolatility indicator of each contract.
        for canonical, chain in slice.option_chains.items():
            for symbol in chain:
                option = self.securities[symbol]
                indicator = option.iv        
        # Sell straddle as an example to trade.
        if not self.portfolio.invested and self._options:
            self.sell(self._options[0], 1)
            self.sell(self._options[1], 1)
        # Liquidate any assigned positions.
        if self.portfolio[self._future.mapped].invested:
            self.liquidate(self._future.mapped)