Weekly Bull Put Credit Spread strategy

Can you help me code for weekly bull put spreads on SPY. Where a trade is only made when the stock is above the 200 period moving average.

Then can the option spread sell the top leg at the strike that has the closest delta to .35. And then buy the strike right below the sold strike.

Then as edit my code so that the stop loss is triggered when, the trade is down by 150% of the profit (credit) received for the strategy.

from AlgorithmImports import *
class BullPutSpreadStrategy(QCAlgorithm): 
   def Initialize(self) -> None:
       self.SetStartDate(2023, 1, 1)
       self.SetEndDate(2023, 12, 1)
       self.SetCash(50000)
       option = self.AddOption("SPY", Resolution.Minute)
       self.symbol = option.Symbol
       option.SetFilter(self.UniverseFunc)
       # Initialize variables for Stop Loss logic
       self.credit_received = 0.0
       self.current_option_strategy = None
   def UniverseFunc(self, universe: OptionFilterUniverse) -> OptionFilterUniverse:
       # return universe.IncludeWeeklys().Strikes(-15, 15).Expiration(timedelta(days=1), timedelta(days=7))
       return universe.IncludeWeeklys().Strikes(-1, 1).Expiration(timedelta(days=1), timedelta(days=7))
   def OnData(self, slice: Slice) -> None:
       if self.Portfolio.Invested: return
       # Get the OptionChain
       chain = slice.OptionChains.get(self.symbol, None)
       if not chain: return
       # Get the furthest expiration date of the contracts
       # expiry = sorted(chain, key=lambda x: x.Expiry, reverse=True)[0].Expiry
       # expiry = [option for option in chain if option.Expiry <= Expiry.EndOfWeek(self.Time)]
       expiry = [option for option in chain if option.Expiry <= Expiry.EndOfWeek(self.Time)]
       # Select the put Option contracts with the furthest expiry
       puts = [i for i in chain if i.Expiry == expiry and i.Right == OptionRight.Put]
       if len(puts) == 0: return
       # Select the ITM and OTM contract strikes from the remaining contracts
       put_strikes = sorted([x.Strike for x in puts])
       lower_otm_strike = put_strikes[0]
       higher_otm_strike = put_strikes[-1]
       option_strategy = OptionStrategies.BullPutSpread(self.symbol, higher_otm_strike, lower_otm_strike, expiry)
       # Check if a new trade is entered and update credit received and option strategy
       if self.current_option_strategy is None:
           self.credit_received = self.Securities[self.symbol].Holdings.UnrealizedProfit
           self.current_option_strategy = option_strategy
           self.Buy(option_strategy, 1)
       else:
           # Check the Stop Loss condition and take necessary actions
           self.CheckStopLoss()
   def CheckStopLoss(self):
       # Calculate the current floating loss
       current_float_loss = self.Securities[self.symbol].Holdings.UnrealizedProfit - self.credit_received
       # Check if the floating loss exceeds 2.38 times the credit received
       if current_float_loss <= -1.5 * self.credit_received:
           # Close the current option strategy trade
           self.Liquidate(self.current_option_strategy)
           # Reset the credit received
           self.credit_received = 0.0
           # Re-enter the trade based on the same rules
           # (Add the logic here to set 'self.current_option_strategy' similar to the existing code)
           self.Buy(self.current_option_strategy, 1)
+ Expand
- Collapse

from AlgorithmImports import *
class BullPutSpreadStrategy(QCAlgorithm):
def initialize(self) -> None:
self.set_start_date(2023, 1, 1)
self.set_end_date(2023, 12, 1)
self.set_cash(50000)
option = self.add_option("SPY", Resolution.MINUTE)
self.symbol = option.Symbol
option.set_filter(self.universe_func)
# Initialize variables for Stop Loss logic
self.credit_received = 0.0
self.current_option_strategy = None
# Add SPY for calculating the moving average
self.spy = self.add_equity("SPY", Resolution.DAILY).Symbol
self.sma = self.sma(self.spy, 200, Resolution.DAILY)
def universe_func(self, universe: OptionFilterUniverse) -> OptionFilterUniverse:
return universe.include_weeklys().strikes(-1, 1).expiration(timedelta(days=1), timedelta(days=7))
def on_data(self, slice: Slice) -> None:
if self.portfolio.invested or not self.sma.is_ready:
return
# Check if SPY is above the 200-period moving average
if self.securities[self.spy].price <= self.sma.current.value:
return
# Get the OptionChain
chain = slice.option_chains.get(self.symbol, None)
if not chain:
return
# Get the nearest expiration date of the contracts
expiry = min([x.Expiry for x in chain])
# Select the put Option contracts with the nearest expiry
puts = [i for i in chain if i.Expiry == expiry and i.right == OptionRight.PUT]
if len(puts) == 0:
return
# Find the put with the closest delta to 0.35
puts = sorted(puts, key=lambda x: abs(x.greeks.delta + 0.35))
short_put = puts[0]
long_put = min([p for p in puts if p.strike < short_put.strike], key=lambda x: x.strike)
# Create the bull put spread strategy
option_strategy = OptionStrategies.bull_put_spread(self.symbol, short_put.strike, long_put.strike, expiry)
# Enter the trade and update credit received and option strategy
if self.current_option_strategy is None:
self.current_option_strategy = option_strategy
self.credit_received = short_put.bid_price - long_put.ask_price
self.buy(option_strategy, 1)
def check_stop_loss(self):
# Calculate the current floating loss
current_float_loss = self.securities[self.symbol].holdings.unrealized_profit - self.credit_received
# Check if the floating loss exceeds 1.5 times the credit received
if current_float_loss <= -1.5 * self.credit_received:
# Close the current option strategy trade
self.liquidate(self.current_option_strategy)
# Reset the credit received
self.credit_received = 0.0
self.current_option_strategy = None

+ Expand

The material on this website is provided for informational purposes only and does not constitute an offer to sell, a solicitation to buy, or a recommendation or endorsement for any security or strategy, nor does it constitute an offer to provide investment advisory services by QuantConnect. In addition, the material offers no opinion with respect to the suitability of any security or specific investment. QuantConnect makes no guarantees as to the accuracy or completeness of the views expressed in the website. The views are subject to change, and may have become unreliable for various reasons, including changes in market conditions or economic circumstances. All investments involve risk, including loss of principal. You should consult with an investment professional before making any investment decisions.

from AlgorithmImports import *
from datetime import timedelta
class BullPutSpreadStrategy(QCAlgorithm):
def initialize(self) -> None:
self.set_start_date(2020, 1, 1)
self.set_end_date(2023, 12, 1)
self.set_cash(50000)
option = self.add_option("SPY", Resolution.MINUTE)
self.symbol = option.Symbol
option.set_filter(self.universe_func)
self.credit_received = 0.0
self.current_option_strategy = None
self.spy = self.add_equity("SPY", Resolution.DAILY).Symbol
self.sma = self.sma(self.spy, 200, Resolution.DAILY)
def universe_func(self, universe: OptionFilterUniverse) -> OptionFilterUniverse:
return universe.include_weeklys().strikes(-1, 1).expiration(timedelta(days=1), timedelta(days=7))
def on_data(self, slice: Slice) -> None:
if not self.sma.is_ready:
return
if self.current_option_strategy is not None:
self.check_stop_loss()
return
if self.securities[self.spy].price <= self.sma.current.value:
return
chain = slice.option_chains.get(self.symbol, None)
if not chain:
return
expiry = min([x.Expiry for x in chain])
puts = [i for i in chain if i.Expiry == expiry and i.right == OptionRight.PUT]
if len(puts) == 0:
return
puts = sorted(puts, key=lambda x: abs(x.greeks.delta + 0.35))
short_put = puts[0]
lower_strike_puts = [p for p in puts if p.strike < short_put.strike]
if not lower_strike_puts:
return
long_put = min(lower_strike_puts, key=lambda x: x.strike)
option_strategy = OptionStrategies.bull_put_spread(self.symbol, short_put.strike, long_put.strike, expiry)
self.current_option_strategy = option_strategy
self.credit_received = short_put.bid_price - long_put.ask_price
self.buy(option_strategy, 1)
def check_stop_loss(self):
current_float_loss = self.securities[self.symbol].holdings.unrealized_profit - self.credit_received
if current_float_loss <= -1.5 * self.credit_received:
self.liquidate(self.current_option_strategy)
self.credit_received = 0.0
self.current_option_strategy = None

+ Expand

from AlgorithmImports import *
from datetime import timedelta
class BullPutSpreadStrategy(QCAlgorithm):
def initialize(self) -> None:
self.set_start_date(2020, 1, 1)
self.set_end_date(2023, 12, 1)
self.set_cash(50000)
option = self.add_option("SPY", Resolution.MINUTE)
self.symbol = option.Symbol
option.set_filter(self.universe_func)
self.spy = self.add_equity("SPY", Resolution.DAILY).Symbol
self.sma = self.sma(self.spy, 200, Resolution.DAILY)
self.active_option_strategies: list = []
def universe_func(self, universe: OptionFilterUniverse) -> OptionFilterUniverse:
return universe.include_weeklys().strikes(-1, 1).expiration(timedelta(days=1), timedelta(days=7))
def on_data(self, slice: Slice) -> None:
if not self.sma.is_ready:
return
# Check stop loss for each active strategy
self.check_stop_loss()
if self.securities[self.spy].price <= self.sma.current.value:
return
chain = slice.option_chains.get(self.symbol, None)
if not chain:
return
expiry = min([x.Expiry for x in chain])
puts = [i for i in chain if i.Expiry == expiry and i.right == OptionRight.PUT]
if len(puts) == 0:
return
puts = sorted(puts, key=lambda x: abs(x.greeks.delta + 0.35))
short_put = puts[0]
lower_strike_puts = [p for p in puts if p.strike < short_put.strike]
if not lower_strike_puts:
return
long_put = min(lower_strike_puts, key=lambda x: x.strike)
option_strategy = OptionStrategies.bull_put_spread(self.symbol, short_put.strike, long_put.strike, expiry)
credit_received = short_put.bid_price - long_put.ask_price
# Add the new strategy to the list of active strategies
self.active_option_strategies.append((option_strategy, credit_received))
self.buy(option_strategy, 1)
def check_stop_loss(self):
for strategy, credit_received in self.active_option_strategies[:]:
current_float_loss = self.securities[self.symbol].holdings.unrealized_profit - credit_received
if current_float_loss <= -1.5 * credit_received:
self.liquidate(strategy)
self.active_option_strategies.remove((strategy, credit_received))

+ Expand

Mia Alissi INVESTOR

October 2024

from AlgorithmImports import *
class BullPutSpreadStrategy(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2023, 1, 1)
        self.set_end_date(2023, 12, 1)
        self.set_cash(50000)
        option = self.add_option("SPY", Resolution.MINUTE)
        self.symbol = option.Symbol
        option.set_filter(self.universe_func)
        # Initialize variables for Stop Loss logic
        self.credit_received = 0.0
        self.current_option_strategy = None
        # Add SPY for calculating the moving average
        self.spy = self.add_equity("SPY", Resolution.DAILY).Symbol
        self.sma = self.sma(self.spy, 200, Resolution.DAILY)
    def universe_func(self, universe: OptionFilterUniverse) -> OptionFilterUniverse:
        return universe.include_weeklys().strikes(-1, 1).expiration(timedelta(days=1), timedelta(days=7))
    def on_data(self, slice: Slice) -> None:
        if self.portfolio.invested or not self.sma.is_ready:
            return
        # Check if SPY is above the 200-period moving average
        if self.securities[self.spy].price <= self.sma.current.value:
            return
        # Get the OptionChain
        chain = slice.option_chains.get(self.symbol, None)
        if not chain:
            return
        # Get the nearest expiration date of the contracts
        expiry = min([x.Expiry for x in chain])
        # Select the put Option contracts with the nearest expiry
        puts = [i for i in chain if i.Expiry == expiry and i.right == OptionRight.PUT]
        if len(puts) == 0:
            return
        # Find the put with the closest delta to 0.35
        puts = sorted(puts, key=lambda x: abs(x.greeks.delta + 0.35))
        short_put = puts[0]
        long_put = min([p for p in puts if p.strike < short_put.strike], key=lambda x: x.strike)
        # Create the bull put spread strategy
        option_strategy = OptionStrategies.bull_put_spread(self.symbol, short_put.strike, long_put.strike, expiry)
        # Enter the trade and update credit received and option strategy
        if self.current_option_strategy is None:
            self.current_option_strategy = option_strategy
            self.credit_received = short_put.bid_price - long_put.ask_price
            self.buy(option_strategy, 1)
    def check_stop_loss(self):
        # Calculate the current floating loss
        current_float_loss = self.securities[self.symbol].holdings.unrealized_profit - self.credit_received
        # Check if the floating loss exceeds 1.5 times the credit received
        if current_float_loss <= -1.5 * self.credit_received:
            # Close the current option strategy trade
            self.liquidate(self.current_option_strategy)
            # Reset the credit received
            self.credit_received = 0.0
            self.current_option_strategy = None
+ Expand
- Collapse

Sources: Index Option Bull Put Spread Algorithm, Index Option Bear Put Spread Algorithm, Bull Put Spread - QuantConnect.com, Index Option Bull Call Spread Algorithm, Bear Put Spread - QuantConnect.com

Upvote

Warren chapman INVESTOR

Can you now please help me edit the strategy so it will take multiple trades. As in the back test it only shows that 1 trade is taken.

from AlgorithmImports import *
from datetime import timedelta
class BullPutSpreadStrategy(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2023, 12, 1)
        self.set_cash(50000)
        option = self.add_option("SPY", Resolution.MINUTE)
        self.symbol = option.Symbol
        option.set_filter(self.universe_func)
        self.credit_received = 0.0
        self.current_option_strategy = None
        self.spy = self.add_equity("SPY", Resolution.DAILY).Symbol
        self.sma = self.sma(self.spy, 200, Resolution.DAILY)
    def universe_func(self, universe: OptionFilterUniverse) -> OptionFilterUniverse:
        return universe.include_weeklys().strikes(-1, 1).expiration(timedelta(days=1), timedelta(days=7))
    def on_data(self, slice: Slice) -> None:
        if not self.sma.is_ready:
            return
        if self.current_option_strategy is not None:
            self.check_stop_loss()
            return
        if self.securities[self.spy].price <= self.sma.current.value:
            return
        chain = slice.option_chains.get(self.symbol, None)
        if not chain:
            return
        expiry = min([x.Expiry for x in chain])
        puts = [i for i in chain if i.Expiry == expiry and i.right == OptionRight.PUT]
        if len(puts) == 0:
            return
        puts = sorted(puts, key=lambda x: abs(x.greeks.delta + 0.35))
        short_put = puts[0]
        lower_strike_puts = [p for p in puts if p.strike < short_put.strike]
        if not lower_strike_puts:
            return
        long_put = min(lower_strike_puts, key=lambda x: x.strike)
        option_strategy = OptionStrategies.bull_put_spread(self.symbol, short_put.strike, long_put.strike, expiry)
        self.current_option_strategy = option_strategy
        self.credit_received = short_put.bid_price - long_put.ask_price
        self.buy(option_strategy, 1)
    def check_stop_loss(self):
        current_float_loss = self.securities[self.symbol].holdings.unrealized_profit - self.credit_received
        if current_float_loss <= -1.5 * self.credit_received:
            self.liquidate(self.current_option_strategy)
            self.credit_received = 0.0
            self.current_option_strategy = None
+ Expand
- Collapse

1 person upvoted this

Warren chapman

warren chapman | October 2024

Has there been any progress?

Mia Alissi

Mia Alissi | October 2024

from AlgorithmImports import *
from datetime import timedelta
class BullPutSpreadStrategy(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2023, 12, 1)
        self.set_cash(50000)
        option = self.add_option("SPY", Resolution.MINUTE)
        self.symbol = option.Symbol
        option.set_filter(self.universe_func)
        self.spy = self.add_equity("SPY", Resolution.DAILY).Symbol
        self.sma = self.sma(self.spy, 200, Resolution.DAILY)
        self.active_option_strategies: list = []
    def universe_func(self, universe: OptionFilterUniverse) -> OptionFilterUniverse:
        return universe.include_weeklys().strikes(-1, 1).expiration(timedelta(days=1), timedelta(days=7))
    def on_data(self, slice: Slice) -> None:
        if not self.sma.is_ready:
            return
        # Check stop loss for each active strategy
        self.check_stop_loss()
        if self.securities[self.spy].price <= self.sma.current.value:
            return
        chain = slice.option_chains.get(self.symbol, None)
        if not chain:
            return
        expiry = min([x.Expiry for x in chain])
        puts = [i for i in chain if i.Expiry == expiry and i.right == OptionRight.PUT]
        if len(puts) == 0:
            return
        puts = sorted(puts, key=lambda x: abs(x.greeks.delta + 0.35))
        short_put = puts[0]
        lower_strike_puts = [p for p in puts if p.strike < short_put.strike]
        if not lower_strike_puts:
            return
        long_put = min(lower_strike_puts, key=lambda x: x.strike)
        option_strategy = OptionStrategies.bull_put_spread(self.symbol, short_put.strike, long_put.strike, expiry)
        credit_received = short_put.bid_price - long_put.ask_price
        # Add the new strategy to the list of active strategies
        self.active_option_strategies.append((option_strategy, credit_received))
        self.buy(option_strategy, 1)
    def check_stop_loss(self):
        for strategy, credit_received in self.active_option_strategies[:]:
            current_float_loss = self.securities[self.symbol].holdings.unrealized_profit - credit_received
            if current_float_loss <= -1.5 * credit_received:
                self.liquidate(strategy)
                self.active_option_strategies.remove((strategy, credit_received))
+ Expand
- Collapse

Sources: Bull Put Spread - QuantConnect.com, Index Option Bull Put Spread Algorithm, Bull Call Spread - QuantConnect.com, Index Option Bull Call Spread Algorithm, Long Put Backspread - QuantConnect.com

Platform

Radically Open-Source Algorithmic Trading Engine

Join Our Discord Channel

Quarterly Open-Source Trading Competition

Draft Discussions

Bookmarked Discussions

SEARCH DISCUSSIONS

377,400 Quants.

VOTE FOR UPCOMING FEATURES

JOIN OUR Community MAILING LIST

IN THIS RESEARCH

PARTICIPANTS

Actions

Join QuantConnect for Free

Platform

SIGN IN

Radically Open-Source Algorithmic Trading Engine

Join Our Discord Channel

Quarterly Open-Source Trading Competition

Draft Discussions

Bookmarked Discussions

SEARCH DISCUSSIONS

377,400 Quants.

VOTE FOR UPCOMING FEATURES

JOIN OUR Community MAILING LIST

IN THIS RESEARCH

PARTICIPANTS

SHARE RESEARCH

SHARE DISCUSSION

SHARE ARTICLE

SHARE

Actions

Join QuantConnect for Free