Difficulty creating program

Hello 'Benrashi',

From your code, it seems like you are trying to implement a strategy where you buy more of a security when its price drops by 5% from the initial purchase price and sell when the price is 5% higher than the purchase price.

However, there are a few issues with your current implementation:

1. The variables Price5PC and PC are local to the OnData method, which means they are reset every time OnData is called. You should make them instance variables (i.e., define them in the Initialize method) so that their values persist across different calls to OnData.

2. You are not updating PC and Price5PC after making a new purchase when the price has dropped by 5%.

3. You are not checking if the price has increased by 5% before placing a sell order. You should only place a sell order if the current price is 5% higher than the purchase price.

Here is a revised version of your code that should work as intended:

class EmotionalSkyBlueCamel(QCAlgorithm):

    def Initialize(self):
        self.SetStartDate(2005, 1, 1)
        self.SetEndDate(2023, 1, 1)
        self.SetCash(100000)
        self.svxy = self.AddEquity("SVXY", Resolution.Hour).Symbol
        self.Price5PC = 0
        self.PC = 0

    def OnData(self, data):
        price = self.Securities[self.svxy].Price

        if not self.Portfolio.Invested and not self.Transactions.GetOpenOrders(self.svxy):
            Quantity =  self.CalculateOrderQuantity(self.svxy, .3)
            self.Price5PC = price * .95
            self.PC = price
            self.MarketOrder("SVXY", Quantity)
            self.LimitOrder("SVXY", Quantity * -1, price*1.05) 

        elif self.Price5PC > price:
            Quantity =  self.CalculateOrderQuantity(self.svxy, .3)
            self.MarketOrder("SVXY", Quantity)
            self.LimitOrder("SVXY", Quantity * -1, price*1.05)
            self.Price5PC = self.PC * .95
            self.PC = price

This code will buy more of the security when its price drops by 5% from the last purchase price and place a limit order to sell when the price is 5% higher than the current purchase price. The Price5PC and PC variables are updated each time a new purchase is made.

Please note that this code does not handle the case where the price increases by 5% before a new purchase is made. You might want to add additional logic to handle this case.

Hope you can help me here too! 

Intent of this program is buying one call & one put at the same time profiting off high volatility. Watched the tutorial video about options trading and after getting the error below back-tested the copy pasted tutorial video code same error, than increased the initial cash balance no change.

“Order Error: ids: [1], Insufficient buying power to complete orders (Value:[498576]), Reason: Id: 1, Initial Margin: 249307.975, Free Margin: 100000.”

# region imports
from AlgorithmImports import *

# endregion

class EmotionalSkyBlueCamel(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2015, 1, 1)
        self.SetEndDate(2023, 1, 1)
        self.SetCash(500000)

        self.svxy = self.AddEquity("SVXY", Resolution.Daily).Symbol
        self.vixy = self.AddEquity("VIXY", Resolution.Daily).Symbol
        
        self.svxyO = self.AddOption("SVXY",Resolution.Hour)

        svxyO.SetFilter(-1,+1,timedelta(6),timedelta(7) )

        self.svxy = svxy.Symbol

        self.UniverseSettings.Leverage = 50

        self.Price5PC = 0
        self.PC = 0

        self.Price5PCU = 0
        self.PCU = 0

        self.IPV = self.Portfolio.TotalPortfolioValue # innitial portfolio value
        
    

    def OnData(self, data):
        price = self.Securities[self.svxy].Price

    
        if not self.Portfolio.Invested:
            Chains = i.Value
            BuyOptions(self, chains)
    
        if self.Portfolio.TotalUnrealisedProfit > 250:
            self.Liquidate(self.svxyO)

    def BuyOptions(self,chains):
        # pick furthest away expiration date
        expiry = sorted(chains, key = lambda x: x.Expiry, reverse = True)[0].Expiry
   
        calls = [i for i in chains if i.expiry == expiry and i.right == OptionRight.Call] 
        puts = [i for i in chains if i.expiry == expiry and i.right == OptionRight.Puts]

        call_contracts = sorted(calls,key = lambda x: abs(x.Strike - x.UnderlyingLastPrice) )
        put_contracts = sorted(puts,key = lambda x: abs(x.Strike - x.UnderlyingLastPrice) )

        self.Call = call_contracts[0]
        self.Puts = put_contracts[0]

        quantity = self.Portfolio.TotalPortfolioValue / self.call.AskPrice
        quantity = int( 0.05 * quantity / 100 )

        if self.Call.AskPrice < self.Portfolio.TotalPortfolioValue:
            self.MarketOrder(self.call.Symbol, 1)
            self.MarketOrder(self.Puts.Symbol, 1)

Hello 'Benrashi',

The error message you're seeing is due to insufficient buying power to complete the orders. This is because the initial margin required for the order is greater than the free margin available in your portfolio.

In your code, you're trying to buy options for the "SVXY" security. However, there are a few issues with your current implementation:

1. You're trying to set the leverage for the universe settings after adding the securities. The leverage setting should be applied before adding the securities.

2. In the BuyOptions method, you're trying to buy options based on the ask price of the call option. However, the ask price is not necessarily the price at which the order will be filled. It would be safer to use the last traded price or the mean of the bid and ask prices to estimate the order cost.

3. You're trying to buy 1 contract of each option without checking if you have enough buying power. You should check if you have enough buying power before placing the order.

4. The BuyOptions method is not properly defined. It should be defined with self as the first argument.

Here is a revised version of your code that should work as intended:

class EmotionalSkyBlueCamel(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2015, 1, 1)
        self.SetEndDate(2023, 1, 1)
        self.SetCash(500000)

        self.UniverseSettings.Leverage = 50

        self.svxy = self.AddEquity("SVXY", Resolution.Daily).Symbol
        self.vixy = self.AddEquity("VIXY", Resolution.Daily).Symbol

        self.svxyO = self.AddOption("SVXY",Resolution.Hour)
        self.svxyO.SetFilter(-1,+1,timedelta(6),timedelta(7) )

        self.Price5PC = 0
        self.PC = 0

        self.Price5PCU = 0
        self.PCU = 0

        self.IPV = self.Portfolio.TotalPortfolioValue # innitial portfolio value

    def OnData(self, data):
        price = self.Securities[self.svxy].Price

        if not self.Portfolio.Invested:
            chains = [i for i in data.OptionChains]
            self.BuyOptions(chains)

        if self.Portfolio.TotalUnrealisedProfit > 250:
            self.Liquidate(self.svxyO)

    def BuyOptions(self, chains):
        # pick furthest away expiration date
        expiry = sorted(chains, key = lambda x: x.Expiry, reverse = True)[0].Expiry

        calls = [i for i in chains if i.Expiry == expiry and i.Right == OptionRight.Call] 
        puts = [i for i in chains if i.Expiry == expiry and i.Right == OptionRight.Put]

        call_contracts = sorted(calls,key = lambda x: abs(x.Strike - x.UnderlyingLastPrice) )
        put_contracts = sorted(puts,key = lambda x: abs(x.Strike - x.UnderlyingLastPrice) )

        self.Call = call_contracts[0]
        self.Put = put_contracts[0]

        quantity = self.Portfolio.TotalPortfolioValue / self.Call.AskPrice
        quantity = int( 0.05 * quantity / 100 )

        if self.Call.AskPrice < self.Portfolio.TotalPortfolioValue:
            self.MarketOrder(self.Call.Symbol, 1)
            self.MarketOrder(self.Put.Symbol, 1)

This code will buy 1 contract of

Thanks for the critiques, not certain why it returned insufficient buying power if the code buys two option contracts valued under 200$ each assume I messed up! The code you put in seems a copy of the code I added, changed some of the initial code made no difference.

Hello 'Benrashi',

The error message "Insufficient buying power" is returned when the initial margin required for the order is greater than the free margin available in your portfolio. This can happen even if the cost of the contracts is less than your total portfolio value, due to the margin requirements of the brokerage or the leverage setting of your algorithm.

In the code I provided, I made some changes to your original code to address potential issues. However, if you're still encountering the same error, it might be due to the specific options contracts you're trying to buy. The margin requirements for options contracts can vary depending on the underlying security, the strike price, and the expiry date.

One way to debug this issue is to log the ask price, bid price, and last traded price of the options contracts before placing the order. This can give you a better idea of the cost of the contracts and whether you have enough buying power to buy them.

Here's how you can add logging to your code:

if self.Call.AskPrice < self.Portfolio.TotalPortfolioValue:
    self.Debug(f"Ask Price: {self.Call.AskPrice}, Bid Price: {self.Call.BidPrice}, Last Price: {self.Call.LastPrice}")
    self.MarketOrder(self.Call.Symbol, 1)
    self.MarketOrder(self.Put.Symbol, 1)

This will print the ask price, bid price, and last traded price of the call option to the console. You can do the same for the put option.

If the ask price is significantly higher than your total portfolio value, this could be the reason why you're getting the "Insufficient buying power" error. In this case, you might need to adjust your strategy to only buy contracts that you can afford.

Problem fixed, new problem! Wondering how to get this code to work as intended, there are no logs visible in the back-tester even when added to the initialize function, and no buy orders are executing. 

from AlgorithmImports import *

class PowerEarningsGap(QCAlgorithm):

    def Initialize(self):
        self.SetStartDate(2022, 7, 2)
        self.SetEndDate(2022, 8, 2)
        self.SetCash(1000000)
        self.Debug("running")

        self.contract = str()
        self.securities = str()

        # add SPY so that we can use it in the schedule rule below
        self.SPY = self.AddEquity('SPY', Resolution.Minute).Symbol

        # build a universe using the CoarseFilter and FineFilter functions defined below
        self.AddUniverse(self.CoarseFilter, self.FineFilter)

        self.SPY = self.AddEquity("SPY").Symbol
        self.Schedule.On(self.DateRules.EveryDay("SPY"), self.TimeRules.AfterMarketOpen("SPY", 1), self.AfterMarketOpen)


    def CoarseFilter(self, universe):
        # filter universe, ensure DollarVolume is above a certain threshold
        # also filter by assets that have fundamental data
        universe = [asset for asset in universe if asset.DollarVolume > 1000000 and asset.Price > 10 and asset.HasFundamentalData]
        
        # sort universe by highest dollar volume
        sortedByDollarVolume = sorted(universe, key=lambda asset: asset.DollarVolume, reverse=True)
        
        # only select the first 500
        topSortedByDollarVolume = sortedByDollarVolume[:500]

        # we must return a list of the symbol objects only
        symbolObjects = [asset.Symbol for asset in topSortedByDollarVolume]

        # this line is not necessary, but we will use it for debugging to see a list of ticker symbols
        tickerSymbolValuesOnly = [symbol.Value for symbol in symbolObjects]

        return symbolObjects

    def FineFilter(self, coarseUniverse):
        yesterday = self.Time - timedelta(days=1)

        fineUniverse = [asset.Symbol for asset in coarseUniverse if asset.EarningReports.FileDate == yesterday and asset.MarketCap > 1e9]

        tickerSymbolValuesOnly = [symbol.Value for symbol in fineUniverse]

        return fineUniverse


    def AfterMarketOpen(self):
        for security in self.ActiveSecurities.Values:
            symbol = security.Symbol
            self.securities = security.Symbol

            if symbol == self.SPY:
                continue

            historyData = self.History(symbol, 2, Resolution.Daily)

            try:
                openDayAfterEarnings = historyData['open'][-1]
                closeDayAfterEarnings = historyData['close'][-1]
                highDayAfterEarnings = historyData['high'][-1]
                closeDayBeforeEarnings = historyData['close'][-2]
            except:
                self.Debug(f"History data unavailable for {symbol.Value}")
                continue

            priceGap = openDayAfterEarnings - closeDayBeforeEarnings
            percentGap = priceGap / closeDayBeforeEarnings
            closeStrength = (closeDayAfterEarnings - openDayAfterEarnings) / (highDayAfterEarnings - openDayAfterEarnings)

            if percentGap > 0.05:
                self.Debug(f"{symbol.Value} gapped up by {percentGap} - {closeDayBeforeEarnings} {openDayAfterEarnings}")

                if closeDayAfterEarnings > closeDayBeforeEarnings and closeStrength > 0.5:
                    self.Debug(f"{symbol.Value} closed strong!")

                    option = self.AddOption(self.securities, Resolution.Minute)
                    option.SetFilter(-1, 1, timedelta(20), timedelta(40))
                    BuyCall()

                else:
                    self.Debug(f"{symbol.Value} faded after earnings")

        
    def BuyPut():
        #if self.contract == str():
        self.contract = self.OptionsFilterPut(data)
        #if not self.Portfolio[self.contract].Invested and data.ContainsKey(self.contract):
        self.Buy(symbol, 1)
    
    def BuyCall():
        #if self.contract == str():
        self.contract = self.OptionsFilterCall(data)
        #elif not self.Portfolio[self.contract].Invested and data.ContainsKey(self.contract):
        self.Buy(symbol, 1)
        

    def OptionsFilterCall(self,data):
        contracts = self.OptionChainProvider.GetOptionContractList(self.Symbol, data.Time)
        self.underlyingPrice = self.Securties(self.securities).Price
        otm_puts = [i for i in contracts if i.ID.OptionRight == OptionRight.Call
                                                                and self.underlyingPrice - i.ID.StrikePrice > self.otm_puts * self.underlyingPrice
                                                                and self.DTE - 8 < (i.ID.Date - data.Time).days < self.DTE + 8]
        
        #if otm puts list is not empty
        if len(otm_puts) > 0:
                contract = sorted(sorted(otm_puts, key = lambda x: abs((x.ID.Date - self.Time).days - self.DTE)),
                                                                                key = lambda x: self.underlyingPrice  - x.ID.StrikePrice)[0]
        
                if contract not in self.contractAdded:
                        self.contractsAdded.Add(self.securities)
                        self.AddOptionContract(self.securities, Resolution.Minute)
                return contract
        else:
            return str()
    
  
    def OptionsFilterPut(self,data):
        contracts = self.OptionChainProvider.GetOptionContractList(self.Symbol, data.Time)
        self.underlyingPrice = self.Securties(self.securities).Price
        otm_puts = [i for i in contracts if i.ID.OptionRight == OptionRight.Put 
                                                                    and self.underlyingPrice - i.ID.StrikePrice > self.otm_puts * self.underlyingPrice
                                                                    and self.DTE - 8 < (i.ID.Date - data.Time).days < self.DTE + 8]
            
        #if otm puts list is not empty
        if len(otm_puts) > 0:
            contract = sorted(sorted(otm_puts, key = lambda x: abs((x.ID.Date - self.Time).days - self.DTE)),
                                                                                    key = lambda x: self.underlyingPrice  - x.ID.StrikePrice)[0]
            
            if contract not in self.contractAdded:
                self.contractsAdded.Add(self.securities)
                self.AddOptionContract(self.securities, Resolution.Minute)
                return contract
            else:
                return str()