Help with 0DTE strategy

Reviewing 'Mislav's' Python code for the 0DTE option strategy, a few potential issues stand out that could prevent the strategy from executing trades as expected:

1. Resolution Mismatch for Index and Options: The algorithm is set to use Resolution.Hour for both the index (SPX) and its options (SPXW). However, for a 0DTE strategy focusing on the very short term, a finer resolution (e.g., Resolution.Minute) might be more appropriate to capture the necessary price movements and option expirations within a single trading day.

2. Option Chain Handling: The algorithm attempts to process option chains directly within the OnData method without checking if the option chain belongs to the SPXW index. This could potentially lead to issues if the algorithm subscribes to other symbols in the future. A more robust approach would be to filter the option chains by the target symbol explicitly.

3. RollingWindow Initialization: The RollingWindow objects for expected_moves and actual_moves are initialized but not instantiated correctly. They should be instantiated with a specific size, e.g., self.expected_moves = RollingWindow[float](5) should be self.expected_moves = RollingWindow[float](5, 0.0) to specify the window size and initial value.

4. Trade Execution Logic: The logic for executing trades based on the comparison of average expected and actual moves seems sound, but there's no explicit check to ensure that trades are only placed on the appropriate days (i.e., days with 0DTE options available). This could be refined by adding a condition to verify that the options being traded indeed expire on the same day.

5. Missing Portfolio Check Before Trading: Before placing new trades, it's a good practice to check if there are any existing positions that need to be closed or managed. The current implementation jumps directly to trading without such checks, which could lead to unintended exposures.

6. Lack of Error Handling: The code does not include any error handling or logging, which could help diagnose issues when the strategy does not behave as expected. Adding logging statements, especially around key decision points like trade execution, could provide valuable insights.

7. OptionStrategies Method Usage: The usage of OptionStrategies.ShortStraddle and OptionStrategies.Straddle might not be correctly implemented as these methods are not standard in the QuantConnect API. Instead, you would typically manually select the call and put options to create a straddle and place orders for them individually.

8. Incorrect Use of Slice Indexing: The code uses slice[atmPut.Symbol].Open and similar expressions, which might not work as expected because slice objects do not directly support indexing by symbol for option contracts. Instead, you should access the price data through the OptionChain object obtained from slice.OptionChains.

To address these issues, consider revising the resolution for more granular data, ensuring proper instantiation and usage of RollingWindow, refining the trade execution logic with additional checks, and incorporating error handling and logging for better diagnostics.

Have you coded for options before? do you have a working template to pull an option and buy in some other code?  When I have a hard time with something I start by just trying to find a way to pull an options contract and store it.  Do a lot of logging to figure out where the problems are.  Do you know if your option chain is even finding a contract?  Have you logged it?  Here is my example of a working way to pull same day DTE0 QQQ contracts for a covered call strategy I ran before

def Buyqqqcoveredcall(self, data):
        if self.coveredcallcontractqqq == str():
            self.logMessage("Obtaining QQQ covered call contract")
            self.coveredcallcontractqqq = self.OptionsFilterqqqcoveredcall(data)
            self.logMessage("Covered QQQ Call contract: {0}".format(self.coveredcallcontractqqq))
            return

        if not self.Portfolio[self.coveredcallcontractqqq].Invested and data.ContainsKey(self.coveredcallcontractqqq):
            Contractstosell = self.qqqnumberofcontracts[0]
            self.logMessage("Covered QQQ Call contract: {0}, Number of contracts to sell: {1}".format(self.coveredcallcontractqqq, Contractstosell))
            self.MarketOrder(self.coveredcallcontractqqq, -Contractstosell)
            self.qqqcoveredcalllist[0] = 1
            self.logMessage("Sold QQQ covered calls: {0}".format(Contractstosell))  
            
    def OptionsFilterqqqcoveredcall(self, data):
        callcontractsqqq = self.OptionChainProvider.GetOptionContractList(self.symbolqqq, data.Time)
        self.underlyingPriceqqq = self.Securities[self.symbolqqq].Price
        qqqotm_calls = [i for i in callcontractsqqq if i.ID.OptionRight == OptionRight.Call and
                                            i.ID.StrikePrice > self.qqqCoveredCallOTM * self.underlyingPriceqqq and
                                            (i.ID.Date - data.Time).days == -1]
                                            
        if len(qqqotm_calls) > 0:
            callqqqcontract = sorted(sorted(qqqotm_calls, key = lambda x: abs(x.ID.StrikePrice - self.underlyingPriceqqq)))[0]
            if callqqqcontract not in self.coveredcallcontractsAddedqqq:
                self.coveredcallcontractsAddedqqq.add(callqqqcontract)
                self.AddOptionContract(callqqqcontract, Resolution.Minute)
            contractarray = sorted(sorted(qqqotm_calls, key = lambda x: abs(x.ID.StrikePrice - self.underlyingPriceqqq)))
            strikes = [x.ID.StrikePrice for x in contractarray]
            self.qqqdtezerostrike[0] = strikes[0]
            self.logMessage("QQQ Opt filter Call contract {0}".format(callqqqcontract))
            self.logMessage("contract strike price: {0}".format(self.qqqdtezerostrike[0]))
            return callqqqcontract
        else:
            return str()

It's not clear what your code is trying to do on these steps:

“Calculate the trade signal” and “Place the appropriate straddle trades”

Can you share the blog post where you learned about the strategy? I'd like to try coding it.

.ekz. , Here is the detailed description of the strategy:

Trading 0DTE Options with the IBKR Native API - Robot Wealth

Got it. Will take a look. Thanks.

.ekz. , Have you looked at blog post :)

I am planning to give it another try next week, so I am interesed have you developed anything ?