def get_options_data(ticker='^GSPC'):
tape = Options(ticker, 'yahoo')
data = tape.get_all_data()
data.to_csv('raw.csv')
data = pd.read_csv('raw.csv')
del data['JSON']
return data
def run(ctx, config_yaml, output_csv):
"""This command loads config.yaml and the current ENV-ironment,
creates a single merged dict, and prints to stdout.
"""
# read the configuration file
c = app.get_config_dict(ctx, [config_yaml])
# use cache to reduce web traffic
session = requests_cache.CachedSession(
cache_name='cache',
backend='sqlite',
expire_after=datetime.timedelta(days=days_to_cache))
# all data will also be combined into one CSV
all_df = None
for ticker in c['config']['options']['long_puts']:
option = Options(ticker, 'yahoo', session=session)
# fetch all data
df = option.get_all_data()
# process the data
df = long_puts_process_dataframe(df)
# ensure the all_df (contains all data from all tickers)
if all_df is None:
all_df = df.copy(deep=True)
else:
all_df = all_df.append(df)
# output the all_df, which contains all of the tickers
long_puts_csv_out(output_csv, all_df)
def update_option_chain():
conn = MySQLdb.connect(host="127.0.0.1",
user="******",
passwd="zhuang123",
db="Analytics")
x = conn.cursor()
columns = [
'ask', 'bid', 'change', 'contractSize', 'contractSymbol', 'currency',
'expiration', 'impliedVolatility', 'inTheMoney', 'lastPrice',
'lastTradeDate', 'openInterest', 'percentChange', 'strike', 'volume',
'pricingDate', 'underlying', 'underlyingPrice', 'type', 'mid'
]
dt_columns = ['expiration', 'lastTradeDate']
for ticker in scrape_list():
try:
option = Options(ticker, 'yahoo')
option_chain = option.get_all_data()
stmt = 'INSERT INTO OptionQuotes VALUES (' + ','.join(
['%s'] * len(columns)) + ')'
for index, option in enumerate(option_chain['JSON'].tolist()):
option['pricingDate'] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
option['underlying'] = option_chain.iloc[index]['Underlying']
option['underlyingPrice'] = option_chain.iloc[index][
'Underlying_Price']
option['type'] = 'call' if (
option['underlyingPrice'] > option['strike']
and option['inTheMoney']) or (
option['underlyingPrice'] < option['strike']
and not option['inTheMoney']) else 'put'
option['mid'] = (option['ask'] + option['bid']) / 2.
values = [
option[column] if column not in dt_columns else
datetime.datetime.fromtimestamp(
option[column]).strftime('%Y-%m-%d %H:%M:%S')
for column in columns
]
print 'update', ticker, 'with values: ', values
x.execute(stmt, tuple(values))
except Exception as e:
print 'failed to update', ticker, 'becasue:', str(e)
conn.commit()
conn.close()
def all_options(ticker, dte_ub, dte_lb, moneyness = 0.03):
tape = Options(ticker, 'yahoo')
data = tape.get_all_data().reset_index()
data['Moneyness'] = np.abs(data['Strike'] - data['Underlying_Price'])/data['Underlying_Price']
data['DTE'] = (data['Expiry'] - dt.datetime.today()).dt.days
data = data[['Strike', 'Expiry','DTE', 'Type', 'IV', 'Underlying_Price',
'Last','Bid','Ask', 'Moneyness']]
data['Mid'] = (data['Ask'] - data['Bid'])/2 + data['Bid']
data = data.dropna()
data = data[(abs(data['Moneyness']) <= moneyness) &
(data['DTE'] <= dte_ub) &
(data['DTE'] >= dte_lb)]
return data.sort_values(['DTE','Type']).reset_index()[data.columns]#data.dropna().reset_index()[data.columns]
def all_options(ticker):
tape = Options(ticker, 'yahoo')
data = tape.get_all_data().reset_index()
data['Moneyness'] = np.abs(
data['Strike'] - data['Underlying_Price']) / data['Underlying_Price']
data['DTE'] = (data['Expiry'].dt.date - dt.datetime.today().date()).dt.days
data = data[[
'Strike', 'DTE', 'Type', 'IV', 'Vol', 'Open_Int', 'Moneyness', 'Root',
'Underlying_Price', 'Last', 'Bid', 'Ask', 'Expiry'
]]
data['Mid'] = (data['Ask'] - data['Bid']) / 2 + data['Bid']
return data.reset_index()[data.columns]
def getOptClosePrice(stock, source, expDate, strick):
df_opt = Options(stock, source)
data = df_opt.get_all_data()
'''
print data.loc[(46, '2018-03-16','call'),('Last','Underlying_Price')].head()
print data.loc[(46, '2018-03-16','call'),'Vol'].head()
print '------------------'
print data.iloc[0:5, 0:5]
print '-------------'
#Show the $100 strike puts at all expiry dates:
'''
#print '1: ' , data.loc[(strick, expDate, 'call'),:] #.iloc[0:5, 0:5]
res = data.loc[(strick, expDate, 'call'),
('Last', 'Underlying_Price')] #.iloc[0:5, 0:5]
# print '1: ' , res
# print '--------------'
return res
def yahoo_options_dataframe(self, ticker):
# fetch all data
option = Options(ticker, 'yahoo', session=self.session)
df = option.get_all_data()
# reset_index()
# copies multi-index values into columns
# sets index to single ordinal integer
df.reset_index(inplace=True)
# rename a bunch of the columns
df.rename(index=str,
inplace=True,
columns={
'Strike': 'strike',
'Expiry': 'expiry',
'Type': 'type',
'Symbol': 'symbol',
'Last': 'lst',
'Bid': 'bid',
'Ask': 'ask',
'Chg': 'chg',
'Vol': 'vol',
'Open_Int': 'oi',
'Root': 'root',
'IsNonstandard': 'nonstandard',
'Underlying': 'underlying',
'Underlying_Price': 'underlyingprice',
'Quote_Time': 'quotetime'
})
# delete unnecessary columns
df.drop('PctChg', axis=1, inplace=True)
df.drop('IV', axis=1, inplace=True)
df.drop('Last_Trade_Date', axis=1, inplace=True)
df.drop('JSON', axis=1, inplace=True)
# normalize values for type column
df['type'] = df.apply(lambda row: 'call'
if row['type'] == 'calls' else 'put',
axis=1)
return df
def compute_model_error(model, symbol, side, exp_start, exp_end, strike_low, strike_high):
#Get the option prices
options_sym = Options(symbol, 'yahoo')
options_sym.expiry_dates
options_data = options_sym.get_all_data()
options_data = options_data.loc[(slice(strike_low,strike_high), slice(exp_start, exp_end), side),:]
#get yesterdays stock price
stock_price = float(Share(symbol).get_price())
labels = ["strike", "expiry", "option price", "pred price", "error"]
data = []
for index, row in options_data.iterrows():
strike = index[0]
expiration_date = index[1].date()
option_price = row['Last']
pred_price = round(model(strike, stock_price, expiration_date, side), 2)
data.append([strike, expiration_date.strftime('%Y-%m-%d'), option_price, pred_price, option_price-pred_price])
return labels, data
def update_option_chain(ticker):
conn = MySQLdb.connect(host="127.0.0.1",
user="******",
passwd="zhuang123",
db="Analytics")
x = conn.cursor()
columns = [
'ask', 'bid', 'change', 'contractSize', 'contractSymbol', 'currency',
'expiration', 'impliedVolatility', 'inTheMoney', 'lastPrice',
'lastTradeDate', 'openInterest', 'percentChange', 'strike', 'volume'
]
dt_columns = ['expiration', 'lastTradeDate']
try:
aapl = Options(ticker, 'yahoo')
option_chain = aapl.get_all_data()
stmt = 'INSERT INTO OptionQuotes VALUES (' + ','.join(
['%s'] * 15) + ')'
for option in option_chain['JSON'].tolist():
x.execute(
stmt,
tuple([
option[column] if column not in dt_columns else
datetime.datetime.fromtimestamp(
option[column]).strftime('%Y-%m-%d %H:%M:%S')
for column in columns
]))
conn.commit()
except Exception as e:
conn.rollback()
print(e)
conn.close()
#update_option_chain('GOOG')
def xwYahooOptionChain(symbol,optype=None,bid=None,minstrike=None,maxstrike=None,expiry=None):
stk = Options(symbol, 'yahoo')
df = stk.get_all_data()
df.drop(['Chg','PctChg','Vol','Open_Int','IV','Root','IsNonstandard','Underlying','Underlying_Price','Quote_Time','Last_Trade_Date','JSON'], axis=1,inplace=True)
df.reset_index(inplace=True)
if optype is not None:
if optype.lower() == 'call': df = df.loc[df['Type'] == 'call']
if optype.lower() == 'put': df = df.loc[df['Type'] == 'put']
if bid is not None:
if bid > 0: df = df.loc[df['Bid'] >= bid]
if minstrike is not None and maxstrike is not None:
if minstrike != maxstrike:
df = df.loc[(df['Strike'] >= minstrike) & (df['Strike'] <= maxstrike)]
df.sort_values(by=['Expiry','Strike','Type'],ascending=[True,True,True],inplace=True)
df.set_index('Expiry',inplace=True)
return df
def all_options(ticker):
tape = Options(ticker, 'yahoo')
data = tape.get_all_data().reset_index()
data['Moneyness'] = np.abs(data['Strike'] - data['Underlying_Price'])/data['Underlying_Price']
data['DTE'] = (data['Expiry'] - dt.datetime.today()).dt.days
data = data[['Strike', 'DTE', 'Type', 'IV', 'Vol','Open_Int', 'Moneyness', 'Root', 'Underlying_Price',
'Last','Bid','Ask']]
data['Mid'] = (data['Ask'] - data['Bid'])/2 + data['Bid']
year = 365
strikes = data['Strike'].values
time_to_expirations = data['DTE'].values
ivs = data['IV'].values
underlying = data['Underlying_Price'].values[0]
types = data['Type'].values
# Make sure nothing thows up
assert len(strikes) == len(time_to_expirations)
sigmas = data['IV']
deltas = []
gammas = []
thetas = []
vegas = []
for sigma, strike, time_to_expiration, flag in zip(sigmas, strikes, time_to_expirations, types):
# Constants
S = underlying
K = strike
t = time_to_expiration/float(year)
r = 0.005 / 100
q = 0 / 100
try:
delta = py_vollib.black_scholes_merton.greeks.analytical.delta(flag[0], S, K, t, r, sigma, q)
deltas.append(delta)
except:
delta = 0.0
deltas.append(delta)
try:
gamma = py_vollib.black_scholes_merton.greeks.analytical.gamma(flag[0], S, K, t, r, sigma, q)
gammas.append(gamma)
except:
gamma = 0.0
gammas.append(gamma)
try:
theta = py_vollib.black_scholes_merton.greeks.analytical.theta(flag[0], S, K, t, r, sigma, q)
thetas.append(theta)
except:
theta = 0.0
thetas.append(theta)
try:
vega = py_vollib.black_scholes_merton.greeks.analytical.vega(flag[0], S, K, t, r, sigma, q)
vegas.append(vega)
except:
vega = 0.0
vegas.append(vega)
data['Delta'] = deltas
data['Gamma'] = gammas
data['Theta'] = thetas
data['Vega'] = vegas
return data.reset_index()[data.columns]#data.dropna().reset_index()[data.columns]
class leg:
def __init__(self, ticker, ask, bid, strike, expiration):
self.ticker = ticker
self.ask = ask
self.bid = bid
self.strike = strike
self.expiration = expiration
'''
Pandas_Datareader returns a dataframe with formatted
option data. Uses a heriarchial index to allow for easy
and specific access of information
'''
ticker = Options('amzn','yahoo')
expiration_dates = ticker.expiry_dates
data = ticker.get_all_data()
yr =2017
mon = 4
day =21
exp_date = dt.datetime(yr, mon, day)
kind = 'call'
raw = data.loc[(900,exp_date,kind),['Ask','Bid']]
bid = float(raw.xs('Bid', axis = 1))
ask = float(raw.xs('Ask', axis = 1))
print(str(ask) +' | '+str(bid))
def get_raw_data(ticker):
tape = Options(ticker, 'yahoo')
data = tape.get_all_data()
return data
def main():
optionschain = Options(SYMBOL, 'yahoo')
dataoptionschain = optionschain.get_all_data()
optionsexpiries = optionschain.expiry_dates
if (optionsexpiries[1].month - optionsexpiries[0].month) > 1:
take3 = 1
else:
take3 = 0
divacc = DIVIDENDSROW(std, dividends, PR)
plt.figure(1, figsize=(8, 12))
plt.subplot(211)
plt.title("Price/Price Dividend Comparison")
plt.xlabel("Date")
plt.ylabel("Price")
plt.plot(datahighlowclosevolume['Close'])
plt.ylim(datahighlowclosevolume['Close'].min() * 0.98,
datahighlowclosevolume['Close'].max() * 1.02)
plt.figure(1, figsize=(8, 12))
plt.subplot(211)
plt.plot(divacc['pricediv'])
plt.ylim(divacc['Close'].min() * 0.98, divacc['pricediv'].max() * 1.02)
plt.figure(2, figsize=(8, 12))
plt.subplot(211)
plt.title("Price/Price Dividend Comparison in %")
plt.xlabel("Date")
plt.ylabel("%")
plt.plot(divacc['priceprc'])
plt.ylim(divacc['priceprc'].min() * 0.98,
divacc['pricedivprc'].max() * 1.02)
plt.figure(2, figsize=(8, 12))
plt.subplot(211)
plt.plot(divacc['pricedivprc'])
plt.ylim(divacc['priceprc'].min() * 0.98,
divacc['pricedivprc'].max() * 1.02)
plt.figure(3, figsize=(8, 12))
plt.subplot(211)
plt.title(
"Price/Price + Dividend + Call Option Short (Covered Call) Comparison")
plt.xlabel("Date")
plt.ylabel("Price")
plt.plot(datahighlowclosevolume['Close'])
plt.ylim(datahighlowclosevolume['Close'].min() * 0.98,
datahighlowclosevolume['Close'].max() * 1.02)
if take3 == 0:
plt.figure(3, figsize=(8, 12))
plt.subplot(211)
plt.plot(divacc['pricediv_option1'])
plt.ylim(divacc['Close'].min() * 0.98,
divacc['pricediv_option1'].max() * 1.02)
else:
plt.figure(3, figsize=(8, 12))
plt.subplot(211)
plt.plot(divacc['pricediv_option3'])
plt.ylim(divacc['Close'].min() * 0.98,
divacc['pricediv_option3'].max() * 1.02)
plt.figure(4, figsize=(8, 12))
plt.subplot(211)
plt.title(
"Price/Price + Dividend + Call Option Short (Covered Call) Comparison in %"
)
plt.xlabel("Date")
plt.ylabel("%")
plt.plot(divacc['priceprc'])
plt.ylim(divacc['priceprc'].min() * 0.98,
divacc['pricedivprc'].max() * 1.02)
if take3 == 0:
plt.figure(4, figsize=(8, 12))
plt.subplot(211)
plt.plot(divacc['pricediv_option1_prc'])
plt.ylim(divacc['priceprc'].min() * 0.98,
divacc['pricediv_option1_prc'].max() * 1.02)
else:
plt.figure(4, figsize=(8, 12))
plt.subplot(211)
plt.plot(divacc['pricediv_option3_prc'])
plt.ylim(divacc['priceprc'].min() * 0.98,
divacc['pricediv_option3_prc'].max() * 1.02)
class OptionLib:
def __init__(self,
symbol='SPY',
dataprovider='yahoo',
riskfree=0.01,
dividendrate=0.01):
self.SYMBOL = symbol
self.data_provider = dataprovider
self.__oldsymbol = symbol
self.__olddataprovider = dataprovider
self.risk_free_rate = riskfree
self.dividend_rate = dividendrate
self.opt = None
self.IVs = {'c': [], 'p': []}
self.__last_quote = None
self.__underlying_price = None
self.__data = None
self.__data_core = None
self.data_selection = (0, 'c')
self.tickSize = 0.5
self.data_init()
#########################################################################################################
# Data Building and Housekeeping #
#########################################################################################################
@waitSyncFlag
def data_init(self):
self.opt = Options(self.SYMBOL, self.data_provider)
self.__underlying_price = self.opt.underlying_price
self.data_building_core()
self.lastGreeks = {'strike': None, 'data': {}, 'S': [], 'T': []}
self.IVs = {'c': [], 'p': []}
self.data_aggregate_IV()
@waitSyncFlag
def data_refresh(self):
self.__underlying_price = self.opt.underlying_price
self.data_building_core()
self.lastGreeks = {'strike': None, 'data': {}, 'S': [], 'T': []}
self.IVs = {'c': [], 'p': []}
self.data_aggregate_IV()
@parallelProcess
def data_auto_refresh(self):
# This should be running in another thread
while True:
if not (self.SYMBOL == self.__oldsymbol
and self.data_provider == self.__olddataprovider):
self.__oldsymbol, self.__olddataprovider = self.SYMBOL, self.data_provider
self.__last_quote = self.opt.get_call_data(
).iloc[0]['Quote_Time'].to_pydatetime()
self.data_init()
print('Data Initialization for {} [ COMPLETE ]'.format(
self.SYMBOL))
if not (self.opt.get_call_data().iloc[0]
['Quote_Time'].to_pydatetime() == self.__last_quote):
self.__last_quote = self.opt.get_call_data(
).iloc[0]['Quote_Time'].to_pydatetime()
self.data_refresh()
print('Data Refreshing for {} [ COMPLETE ]'.format(
self.SYMBOL))
@requireSyncFlag
def data_building_core(self):
try:
assert self.opt
df = self.opt.get_all_data()
dflen = len(df.index.values)
d = {}
for i in range(dflen):
dfindex = df.index.values[i]
row = df.loc[dfindex]
exp = dfindex[1].to_pydatetime()
curr = row['Quote_Time'].to_pydatetime()
toe = float((exp - curr).days) / 365.0
# Days until expiration
dte = round(toe * 365) + 1
otype = 'c' if dfindex[2] == 'call' else 'p'
# Index will be using expiry_date index
expd = exp.date()
j = self.opt.expiry_dates.index(expd)
bso = Black_Scholes(option_type=otype,
price=row['Underlying_Price'],
strike=dfindex[0],
interest_rate=self.risk_free_rate,
dividend_yield=self.dividend_rate,
volatility=row['IV'],
expiry=toe)
# Check if the index exists or not
if not (j in d):
d[j] = {'matrix': [], 'indexes': []}
# [ [ Ask, Bid, Last, Vol, %, sigma, delta, gamma, kappa, theta, rho, dte, symbol] , (...) ]
d[j]['matrix'].append([
row['Ask'], row['Bid'], row['Last'],
int(row['Vol']), row['PctChg'],
round(row['IV'], 2),
round(bso.delta, 2),
round(bso.gamma, 2),
round(bso.kappa, 2),
round(bso.theta, 2),
round(bso.rho, 2), dte, dfindex[3]
])
# [ ( type, strike), ... ]
d[j]['indexes'].append((otype, dfindex[0]))
self.__data_core = d
except AssertionError:
raise DataFormatError(
'No Data from Yahoo, Check Internet Connection')
@requireSyncFlag
def data_aggregate_IV(self):
"""
Aggregate Contract's sigma by call and puts then store them in [ Time to Expiration, Strike, Volatility ]
format for later plotting
"""
try:
assert self.__data_core
d = self.__data_core.copy()
for t in d.keys():
matrix = d[t]['matrix']
indexes = d[t]['indexes']
for i in range(len(matrix)):
# Format : [ Time to Expiration, Strike, Volatility ]
self.IVs[indexes[i][0]].append(
[matrix[i][11], indexes[i][1], matrix[i][5]])
except AssertionError:
raise DataFormatError('Must input a pandas.DataFrame')
def data_IVpT(self, expiry_index=0):
"""
Compute IV per timestamp
:return: calls and puts
"""
dt = self.__data_core[expiry_index].copy()
matrix = dt['matrix']
indexes = dt['indexes']
calls, puts = [], []
# calls = [ [ Strike, IV] , ... ]
for i in range(len(matrix)):
if indexes[i][0] == 'c':
calls.append([indexes[i][1], matrix[i][5]])
else:
puts.append([indexes[i][1], matrix[i][5]])
return calls, puts
def data_aggregate_greeks(self, strike=None):
"""
:return:
"""
try:
assert self.__data_core
assert strike
d = self.__data_core.copy()
times = []
sigmas = []
for t in d.keys():
matrix = d[t]['matrix']
indexes = d[t]['indexes']
for i in range(len(matrix)):
if indexes[i][0] == 'c' and indexes[i][1] == strike:
sigmas.append(matrix[i][5])
times.append(float(matrix[i][11]) / 365.0)
# Matrices are n x m
# where n : the nb of contract_dates
# compute underlyingPrice matrix
underlyingPriceMatrix = np.array([
np.arange(0.0, self.__underlying_price * 2, self.tickSize)
for i in range(len(sigmas))
])
MatrixShape = underlyingPriceMatrix.shape
sigmaMatrix = np.array([
np.ones(MatrixShape[1]) * sigmas[i]
for i in range(MatrixShape[0])
]).reshape(MatrixShape)
expiryMatrix = np.array([
np.ones(MatrixShape[1]) * times[i]
for i in range(MatrixShape[0])
]).reshape(MatrixShape)
ccontracts = []
pcontracts = []
for i in range(MatrixShape[0]):
for j in range(MatrixShape[1]):
cbso = Black_Scholes(option_type='c',
strike=strike,
price=underlyingPriceMatrix[i][j],
interest_rate=self.risk_free_rate,
dividend_yield=self.dividend_rate,
expiry=expiryMatrix[i][j],
volatility=sigmaMatrix[i][j])
pbso = Black_Scholes(option_type='p',
strike=strike,
price=underlyingPriceMatrix[i][j],
interest_rate=self.risk_free_rate,
dividend_yield=self.dividend_rate,
expiry=expiryMatrix[i][j],
volatility=sigmaMatrix[i][j])
#Access elements in matrix[i][j]
ccontracts.append(cbso)
pcontracts.append(pbso)
cdelta = np.array([c.delta
for c in ccontracts]).reshape(MatrixShape)
cgamma = np.array([c.gamma
for c in ccontracts]).reshape(MatrixShape)
ctheta = np.array([c.theta
for c in ccontracts]).reshape(MatrixShape)
ckappa = np.array([c.kappa
for c in ccontracts]).reshape(MatrixShape)
crho = np.array([c.rho for c in ccontracts]).reshape(MatrixShape)
pdelta = np.array([p.delta
for p in pcontracts]).reshape(MatrixShape)
pgamma = np.array([p.gamma
for p in pcontracts]).reshape(MatrixShape)
ptheta = np.array([p.theta
for p in pcontracts]).reshape(MatrixShape)
pkappa = np.array([p.kappa
for p in pcontracts]).reshape(MatrixShape)
prho = np.array([p.rho for p in pcontracts]).reshape(MatrixShape)
greeks = {'c': {}, 'p': {}}
greeks['c']['delta'] = cdelta
greeks['c']['gamma'] = cgamma
greeks['c']['theta'] = ctheta
greeks['c']['kappa'] = ckappa
greeks['c']['rho'] = crho
greeks['p']['delta'] = pdelta
greeks['p']['gamma'] = pgamma
greeks['p']['theta'] = ptheta
greeks['p']['kappa'] = pkappa
greeks['p']['rho'] = prho
self.lastGreeks['data'] = greeks
self.lastGreeks['strike'] = strike
self.lastGreeks['S'] = underlyingPriceMatrix
self.lastGreeks['T'] = expiryMatrix
except AssertionError:
pass
pass
#########################################################################################################
# Client's Methods and Properties #
#########################################################################################################
@property
def index(self):
opt = self.opt
d = {'Expiry Dates': opt.expiry_dates}
return pd.DataFrame(data=d).transpose()
@property
def data(self):
print('Underlying @ {:.2f} \nLatest Option Quote @: {}\n'.format(
self.__underlying_price, self.__last_quote))
print('Current Contracts Expires @ {}\n'.format(
self.opt.expiry_dates[self.data_selection[0]]))
obj = self.__data_core[self.data_selection[0]]
data = np.array(obj['matrix'])
indexes = obj['indexes']
filtered_matrix = []
filtered_indexes = []
for i in range(len(data)):
if indexes[i][0] == self.data_selection[1]:
filtered_matrix.append(data[i])
filtered_indexes.append(indexes[i][1])
columns = [
'Ask', 'Bid', 'Last', 'Vol', '%', '\u03C3', '\u0394', '\u0393',
'\u039A', '\u0398', '\u03A1', 'Days to Expiry', 'Symbol'
]
df = pd.DataFrame(data=filtered_matrix,
index=filtered_indexes,
columns=columns)
return df
@property
def VIEW_SELECTION(self):
return 'CURRENTLY SELECTED DATA :: [ INDEX : {} | TYPE : {} | SYMBOL : {} ]'.format(
self.data_selection[0], self.data_selection[1], self.SYMBOL)
def select(
self,
INDEX=0,
TYPE='c',
):
"""
Setting the data-selecting tuple
"""
try:
assert TYPE == 'c' or TYPE == 'p'
assert INDEX < len(self.opt.expiry_dates)
self.data_selection = (INDEX, TYPE)
except AssertionError:
raise DataFormatError(
'Expiry index and option type ("c" or "p") must be valid')
#########################################################################################################
# Plotting #
#########################################################################################################
def plot_smile(
self,
expiry_index=None,
):
"""
Plot the IV smile for both calls and puts per timestamp
"""
expiry_index = expiry_index if expiry_index else self.data_selection[0]
calls, puts = self.data_IVpT(expiry_index=expiry_index)
k_calls, IV_calls = [], []
k_puts, IV_puts = [], []
for el in calls:
k_calls.append(el[0])
IV_calls.append(el[1])
for el in puts:
k_puts.append(el[0])
IV_puts.append(el[1])
plt.figure(figsize=(16, 7))
e = plt.scatter(k_calls, IV_calls, c='white', label="IV(call options)")
f = plt.scatter(k_puts, IV_puts, c='red', label="IV(put options)")
plt.xlabel('strike')
plt.ylabel('Implied Volatility')
plt.legend((e, f), ("IV (call options)", "IV (put options)"))
def plot_surface(
self,
option_type=None,
):
try:
if option_type:
assert option_type == 'c' or option_type == 'p'
option_type = option_type if option_type else self.data_selection[1]
plotdata = self.IVs[option_type]
color = 'red' if option_type == 'p' else 'green'
xaxis = [plotdata[i][0] for i in range(len(plotdata))]
yaxis = [plotdata[i][1] for i in range(len(plotdata))]
zaxis = [plotdata[i][2] for i in range(len(plotdata))]
fig1 = plt.figure(figsize=(20, 12))
ax = fig1.add_subplot(111, projection='3d')
ax.view_init()
ax.scatter(xaxis, yaxis, zaxis, c=color)
plt.xlabel("Time to Expiration (days)")
plt.ylabel("Strikes")
plt.title("Implied Volatility")
fig2 = plt.figure(figsize=(20, 12))
ax2 = fig2.add_subplot(111, projection='3d')
ax2.view_init()
ax2.plot_trisurf(xaxis, yaxis, zaxis, cmap=cm.jet)
plt.xlabel("Time to Expiration (days)")
plt.ylabel("Strikes")
plt.title("Implied Volatility")
except AssertionError:
print(
'You must specify option type as first argument and/or Invalid option type'
)
except Exception as e:
print(e)
def plot_letter(self, LETTER=None, STRIKE=None, otype='c'):
try:
assert LETTER in ['delta', 'gamma', 'theta', 'kappa', 'rho']
data = {}
S, T = [], []
strike = STRIKE if STRIKE else np.round(self.__underlying_price)
if self.lastGreeks['strike'] and self.lastGreeks[
'strike'] == strike:
data, S, T = self.lastGreeks['data'], self.lastGreeks[
'S'], self.lastGreeks['T']
else:
self.data_aggregate_greeks(strike=strike)
data, S, T = self.lastGreeks['data'], self.lastGreeks[
'S'], self.lastGreeks['T']
print('Plotting {} with Strike {} for {} - {}\n'.format(
LETTER, strike, self.SYMBOL, otype))
Z = data[otype][LETTER]
fig = plt.figure(figsize=(20, 11))
ax = fig.add_subplot(111, projection='3d')
ax.view_init(40, 290)
ax.plot_wireframe(S, T, Z, rstride=1, cstride=1)
ax.plot_surface(S,
T,
Z,
facecolors=cm.jet(Z),
linewidth=0.001,
rstride=1,
cstride=1,
alpha=0.75)
ax.set_zlim3d(0, Z.max())
ax.set_xlabel('Stock Price')
ax.set_ylabel('Time to Expiration')
ax.set_zlabel(LETTER)
m = cm.ScalarMappable(cmap=cm.jet)
m.set_array(Z)
cbarDelta = plt.colorbar(m)
except AssertionError:
raise DataFormatError('Invalid Letter')
except ValueError:
raise DataFormatError(
'Invalid Calculations for {} :: Something went wrong on our end :$'
.format(LETTER))
from pandas_datareader.data import Options
import pandas as pd
from pandas import DataFrame
import datetime
import csv
import time
import sys
tickers = pd.read_csv('nxxx.csv', index_col=[0]) #List of Nyse symbols, Add Nasdaq
money_list = [] #List from which we send option symbols to a .csv file
for i in tickers.index:
option = Options(i,'yahoo')
data = option.get_all_data()
# The returned data is a pandas DataFrame: http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.html
# RTFM
if not data.empty :
i = 0
while i < 5:
try:
#money_list.append(data[data.Vol > 1000].index.get_level_values('Symbol'))
print data[Symbol]
except Exception as e:
print "ERROR: " + str(e)
time.sleep(1)
def get_data():
spy = Options('spy', 'yahoo')
chain = spy.get_all_data()
filename = './spy_' + strftime("%Y-%m-%d %H:%M:%S", gmtime()) + '.bin'
pickle_store(chain, filename)
import pandas as pd
import pandas.io.data as web
import numpy as np
import datetime
import csv
import os
import urllib
import re
from pandas_datareader.data import Options
tsla = Options('TSLA', 'yahoo')
data = tsla.get_all_data()
data.iloc[0:5, 0:5]
def Option_data(options=None, n=2000):
'''
Get option data from Yahoo Finance
Remove incomplete option data and outliers, provide a concise data description,
calculate Time to Maturity, and save the clean data as a csv data file
clean criteria: Last_Trade_Date = 1/1/1970
clean outliers (implied volatility > 2)
:param options: enter one name or a ticker name list,
or randomly select all options of n tickers if no option entered
:param n: number of tickers, default 2000
:return: option data review and save as a csv file
'''
data = pd.DataFrame()
if options is None:
df = pd.read_csv('ticker_list.csv')
company = df['Symbol']
i = 0
selected_list = []
while i < n:
if n > len(df):
print(
'\nPlease select fewer tickers, the maximum number of tickers is '
+ str(len(df)))
break
name_list = set(company.sample(n - i).tolist())
for item in (name_list - set(selected_list)):
try:
name = Options(item, 'yahoo')
ticker = name.get_all_data()
data = data.append(ticker)
i += 1
except:
pass
continue
selected_list = data.Underlying.tolist()
else:
if type(options) is str: #only select one ticker
try:
name = Options(options, 'yahoo')
data = name.get_all_data()
except:
print(str(options) + ' is not optionable')
else:
for item in list(options): # select a list of tickers
try:
name = Options(item, 'yahoo')
ticker = name.get_all_data()
data = data.append(ticker)
except:
(str(options) + ' is not optionable')
continue
del data['JSON']
df = data.dropna()
df['Last_Trade_Date'] = pd.to_datetime(df['Last_Trade_Date'])
df = df[df['Last_Trade_Date'].dt.year != 1970]
df = df[df['IV'] <= 2]
df = df[df['Last'] != 0]
df['T'] = (pd.to_datetime(df['Expiry']) -
pd.to_datetime(df['Quote_Time'])) / np.timedelta64(1, 'Y')
df.to_csv('option_clean.csv')
print df.describe()
return df