Earnings Disagreement Put Spread Strategy on S&P 100 Options

1from AlgoLib import *
2from numpy import floor
3#endregion
4
5class DispersionTrading(XXX):
6
7def Initialize(self):
8self.SetStartDate(2010, 1, 1)
9self.SetCash(1000000)
10
11self.min_expiry:int = 20
12self.max_expiry:int = 60
13
14self.leverage:int = 5
15self.min_share_price:int = 5
16self.buying_power_model:int = 2
17
18self.index_symbol:Symbol = self.AddIndex('SPX').Symbol
19self.percentage_traded:float = 1.0
20
21self.selected_symbols:List[Symbol] = []
22self.subscribed_contracts = {}
23
24self.fundamental_sorting_key = lambda x: x.DollarVolume
25self.fundamental_count:int = 100
26self.Settings.MinimumOrderMarginPortfolioPercentage = 0.
27self.UniverseSettings.Resolution = Resolution.Minute
28self.AddUniverse(self.FundamentalSelectionFunction)
29self.SetSecurityInitializer(lambda x: x.SetDataNormalizationMode(DataNormalizationMode.Raw))
30self.UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw
31
32def OnSecuritiesChanged(self, changes: SecurityChanges) -> None:
33for security in changes.AddedSecurities:
34    security.SetFeeModel(CustomFeeModel())
35    security.SetLeverage(self.leverage)
36
37def FundamentalSelectionFunction(self, fundamental: List[Fundamental]) -> List[Symbol]:
38# rebalance on SPX contract expiration (should be on monthly basis)
39if len(self.selected_symbols) != 0:
40    return Universe.Unchanged
41
42# select top n stocks by dollar volume
43selected:List[Fundamental] = [x for x in fundamental if x.HasFundamentalData and x.Market == 'usa' and x.AdjustedPrice > self.min_share_price]
44
45if len(selected) > self.fundamental_count:
46    selected = [x for x in sorted(selected, key=self.fundamental_sorting_key, reverse=True)[:self.fundamental_count]]
47
48self.selected_symbols = [x.Symbol for x in selected]
49
50return self.selected_symbols
51
52def OnData(self, data: Slice) -> None:
53# liquidate portfolio, when SPX contract is about to expire in 2 days
54if self.index_symbol in self.subscribed_contracts and self.subscribed_contracts[self.index_symbol].ID.Date.date() - timedelta(2) <= self.Time.date():
55    self.subscribed_contracts.clear()   # perform new subscribtion
56    self.selected_symbols.clear()       # perform new selection
57    self.Liquidate()
58    
59if len(self.subscribed_contracts) == 0:
60    if self.Portfolio.Invested:
61        self.Liquidate()
62    
63    # NOTE order is important, index should come first
64    for symbol in [self.index_symbol] + self.selected_symbols:
65        # subscribe to contract
66        contracts:List[Symbol] = self.OptionChainProvider.GetOptionContractList(symbol, self.Time)
67        # get current price for stock
68        underlying_price:float = self.Securities[symbol].Price
69        
70        # get strikes from stock contracts
71        strikes:List[float] = [i.ID.StrikePrice for i in contracts]
72        
73        # check if there is at least one strike    
74        if len(strikes) <= 0:
75            continue
76    
77        # at the money
78        atm_strike:float = min(strikes, key=lambda x: abs(x-underlying_price))
79
80        # filtred contracts based on option rights and strikes
81        atm_puts:List[Symbol] = [i for i in contracts if i.ID.OptionRight == OptionRight.Put and 
82                                             i.ID.StrikePrice == atm_strike and 
83                                             self.min_expiry <= (i.ID.Date - self.Time).days <= self.max_expiry]
84
85        # index contract is found
86        if symbol == self.index_symbol and len(atm_puts) == 0:
87            # cancel whole selection since index contract was not found
88            return
89            
90        # make sure there are enough contracts
91        if len(atm_puts) > 0:
92            # sort by expiry
93            atm_put:List[Symbol] = sorted(atm_puts, key = lambda item: item.ID.Date, reverse=True)[0]
94            
95            # add contract
96            option = self.AddOptionContract(atm_put, Resolution.Minute)
97            option.PriceModel = OptionPriceModels.CrankNicolsonFD()
98            option.SetDataNormalizationMode(DataNormalizationMode.Raw)
99
100            # store subscribed atm put contract
101            self.subscribed_contracts[symbol] = atm_put
102
103# perform trade, when spx and stocks contracts are selected            
104if not self.Portfolio.Invested and len(self.subscribed_contracts) != 0 and self.index_symbol in self.subscribed_contracts:
105    index_option_contract = self.subscribed_contracts[self.index_symbol]
106    # make sure subscribed SPX contract has data
107    if self.Securities.ContainsKey(index_option_contract):
108        if self.Securities[index_option_contract].Price != 0 and self.Securities[index_option_contract].IsTradable:
109            # sell SPX ATM put contract
110            self.Securities[index_option_contract].MarginModel = BuyingPowerModel(self.buying_power_model)
111            price:float = self.Securities[self.index_symbol].Price
112            if price != 0:
113                q:int = floor((self.Portfolio.TotalPortfolioValue * self.percentage_traded) / (price*100))
114                self.Sell(index_option_contract, q)
115
116            # buy stock's ATM put contracts            
117            long_count:int = len(self.subscribed_contracts) - 1     # minus index symbol
118            for stock_symbol, stock_option_contract in self.subscribed_contracts.items():
119                if stock_symbol == self.index_symbol:
120                    continue
121                
122                if stock_option_contract in data and data[stock_option_contract]:
123                    if self.Securities[stock_option_contract].Price != 0 and self.Securities[stock_option_contract].IsTradable:
124                        # buy contract
125                        self.Securities[stock_option_contract].MarginModel = BuyingPowerModel(self.buying_power_model)
126                        if self.Securities.ContainsKey(stock_option_contract):
127                            price:float = self.Securities[stock_symbol].Price
128                            if price != 0:
129                                q:int = floor(((self.Portfolio.TotalPortfolioValue / long_count) * self.percentage_traded) / (price*100))
130                                self.Buy(stock_option_contract, q)
131
132# Custom fee model
133class CustomFeeModel(FeeModel):
134def GetOrderFee(self, parameters):
135fee = parameters.Security.Price * parameters.Order.AbsoluteQuantity * 0.00005
136return OrderFee(CashAmount(fee, "USD"))