Mispricing of Equity Options With Different Time To Maturity

1from AlgorithmImports import *
2#endregion
3class MispricingofxOptionsWithDifferentTimeToMaturity(QCAlgorithm):
4def Initialize(self):
5self.SetStartDate(2015, 1, 1)
6self.SetCash(1000000)
7
8self.min_share_price:int = 5
9self.min_expiry:int = 18
10self.max_expiry:int = 22
11self.percentage_traded:float = 1
12self.selected_symbols:list[Symbol] = {}
13self.subscribed_contracts:dict[Symbol, Contracts] = {}
14
15self.weeks_counter:int = 0
16self.rebalance_period:int = 3
17self.weekday_num:int = 3 # represents thursday
18self.market_symbol:Symbol = self.AddEquity('SPY', Resolution.Minute).Symbol
19self.recent_day:int = -1
20self.recent_month:int = -1
21self.fundamental_sorting_key = lambda x: x.DollarVolume
22self.fundamental_count:int = 100
23self.selection_flag:bool = False
24self.settings.daily_precise_end_time = False
25self.Settings.MinimumOrderMarginPortfolioPercentage = 0.
26self.UniverseSettings.Resolution = Resolution.Minute
27self.AddUniverse(self.FundamentalSelectionFunction)
28self.SetSecurityInitializer(lambda x: x.SetDataNormalizationMode(DataNormalizationMode.Raw))
29self.UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw
30def FundamentalSelectionFunction(self, fundamental: List[Fundamental]) -> List[Symbol]:
31# rebalance, when contracts expiried
32if not self.selection_flag:
33    return Universe.Unchanged
34
35selected:list = [
36    x for x in fundamental if x.HasFundamentalData and x.Market == 'usa' and x.Price >= self.min_share_price
37]
38if len(selected) > self.fundamental_count:
39    selected = [x for x in sorted(selected, key=self.fundamental_sorting_key, reverse=True)[:self.fundamental_count]]
40self.selected_symbols = list(map(lambda stock: stock.Symbol, selected))
41
42return self.selected_symbols
43def OnData(self, data: Slice):
44curr_date:datetime.date = self.Time.date()
45# execute once a day
46if self.recent_day != curr_date.day:
47    self.recent_day = curr_date.day
48    if self.recent_month != curr_date.month:
49        self.recent_month = curr_date.month
50        self.weeks_counter = 0
51    
52    # check if any of the subscribed contracts expired
53    for symbol in self.selected_symbols:
54        if symbol in self.subscribed_contracts and self.subscribed_contracts[symbol].expiry_date <= self.Time.date():
55            # remove expired contracts
56            for contract in self.subscribed_contracts[symbol].contracts:
57                if self.Securities[contract].IsTradable:
58                    # self.RemoveSecurity(contract)
59                    self.Liquidate(contract)
60                
61            del self.subscribed_contracts[symbol]
62
63    if curr_date.weekday() == self.weekday_num:
64        # increase week counter at the specific day of the week
65        self.weeks_counter += 1
66        # allow rebalance on the third thursday of the month,
67        # because stocks and contracts will be subscribed on the third friday of the month
68        if self.weeks_counter % self.rebalance_period == 0:
69            self.subscribed_contracts.clear()
70            self.selected_symbols.clear()
71            self.selection_flag = True
72            return
73    
74    # subscribe to new contracts after selection
75    if len(self.subscribed_contracts) == 0 and self.selection_flag:
76        for symbol in self.selected_symbols:
77            # get all contracts for current stock symbol
78            contracts:list[Symbol] = self.OptionChainProvider.GetOptionContractList(symbol, self.Time)
79            underlying_price:float = self.Securities[symbol].Price
80            
81            strikes:list = [i.ID.StrikePrice for i in contracts]
82            
83            # can't filter contracts, if there isn't any strike price
84            if len(strikes) <= 0 or underlying_price == 0:
85                continue
86            
87            call:Symbol|None = self.FilterContracts(strikes, contracts, underlying_price)
88            if call:
89                subscriptions:list = self.SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(call.Underlying)
90                if subscriptions:
91                    self.AddContract(call)
92                    expiry_date:datetime.date = call.ID.Date.date()                    
93                    self.subscribed_contracts[symbol] = Contracts(expiry_date, underlying_price, [call])
94# this triggers next minute after new contracts subscription
95elif len(self.subscribed_contracts) != 0 and self.selection_flag:
96    self.selection_flag = False # this makes sure, there will be no other trades until next selection
97    # trade execution
98    self.Liquidate()
99    length:int = len(self.selected_symbols)
100    for symbol in self.selected_symbols:
101        if symbol in data and data[symbol]:
102            if symbol not in self.subscribed_contracts:
103                continue
104            call = self.subscribed_contracts[symbol].contracts[0]
105            underlying_price:float = self.subscribed_contracts[symbol].underlying_price
106            
107            options_q:int = int(((self.Portfolio.TotalPortfolioValue * self.percentage_traded) / length) / (underlying_price * 100))
108            
109            if call in data and data[call] != 0 and symbol in data and data[symbol]:
110                self.Sell(call, options_q)
111                # delta hedge
112                self.SetHoldings(symbol, (1 / length) * self.percentage_traded)
113
114def FilterContracts(self, strikes:list, contracts:list, underlying_price:float):
115''' filter call contracts from contracts parameter '''
116''' return call contract '''
117
118result = None
119atm_strike:float = min(strikes, key=lambda x: abs(x-underlying_price))
120
121# filtred contracts based on option rights and strikes
122atm_calls:list[Symbol] = [i for i in contracts if i.ID.OptionRight == OptionRight.Call and 
123                                        i.ID.StrikePrice == atm_strike and 
124                                        self.min_expiry <= (i.ID.Date - self.Time).days <= self.max_expiry]
125if len(atm_calls) > 0:
126    # sort by expiry
127    result = sorted(atm_calls, key = lambda item: item.ID.Date, reverse=True)[0]
128return result
129
130def AddContract(self, contract) -> None:
131''' subscribe option contract, set price mondel and normalization mode '''
132option = self.AddOptionContract(contract, Resolution.Minute)
133option.PriceModel = OptionPriceModels.BlackScholes()
134
135class Contracts():
136def __init__(self, expiry_date, underlying_price, contracts):
137self.expiry_date = expiry_date
138self.underlying_price = underlying_price
139self.contracts = contracts