def main2(): m = stockMongo() prices = [] try: dates = options.get_expiration_dates('AAPL') try: prices = options.get_options_chain('AAPL', dates[14]) price_calls = pd.DataFrame.from_dict(prices['calls']) price_puts = pd.DataFrame.from_dict(prices['puts']) strike_date = datetime.datetime.strptime(dates[14], '%B %d, %Y') price_calls['strike-date'] = strike_date price_puts['strike-date'] = strike_date now = datetime.datetime.now() #now = datetime.datetime.strptime(now.strftime("%m/%d/%Y"),"%m/%d/%Y") price_puts['date'] = now price_calls['date'] = now price_calls['type'] = 'call' price_puts['type'] = 'put' m = stockMongo() m.update_options('AAPL', price_calls, now, 'call') m.update_options('AAPL', price_puts, now, 'put') print("Options updated and stored") except: print("no prices") except: print("No date")
def main(): print("getting symbols") m = stockMongo() symbols = m.get_symbols() tickers = [] for sym in symbols: tickers.append(sym['sym']) print("running data collection") fails = [] for tick in tickers: try: dates = options.get_expiration_dates(tick) if len(dates) == 0: print(tick + " has no optiondates") if len(tickers) < 2: time.sleep(180) else: time.sleep(60) tickers.append(tick) #m = stockMongo() #m.remove(tick) for day in dates: val = collect_options(tick, day) if not val: fails.append(tick) time.sleep(60) except: print(tick) print(tick)
def get_options_expirations(self): if not self.live_prices_released(): filename = 'Chains/' + self.ticker + '_' + 'expirations.pickle' expirations = pickle.load(open(filename, "rb")) else: expirations = options.get_expiration_dates(self.ticker) return [{"label": i, "value": i} for i in expirations]
def daily_options_calc(target_folder, tickers): #first change all tickers to uppercase tickers = [i.upper() for i in tickers] #first check to make sure all tickers are valid: for t in tickers: try: si.get_live_price(t) except: print('') #each ticker will have a separate excel file/collection of databases corresponding with a ticker historical_loc = target_folder #FIRST GET LIST OF TICKERS WITH DATA ALREADY COLLECTED, INTERSECT WITH LIST OF TICKERS REQUESTED existing_tickers = [i[0:i.index('.')] for i in os.listdir(historical_loc)] new_tickers = [i for i in tickers if i not in existing_tickers] rate = stock_options.get_current_risk_free_interest_rate()/100 date_today = datetime.datetime.today() date_today = '{}-{}-{}'.format(date_today.month, date_today.day, date_today.year) for t in existing_tickers: print('updating {}'.format(t)) #stock price for today stock_price = si.get_live_price(t) #all expiration dates all_dates = options.get_expiration_dates(t) existing_dates = pd.ExcelFile(historical_loc+t+'.xlsx').sheet_names new_dates = [i for i in all_dates if i not in existing_dates] #first get list of tabs available #each date will correspond with a differnt tab in excel sheet/ different table/ different database print('updating options information on existing dates') existing_dates_calc(existing_dates, stock_price, date_today, rate,historical_loc, t) if len(new_dates)>0: print('getting values for new options on new dates') new_dates_calc(new_dates, stock_price, date_today,rate,historical_loc, t) for t in new_tickers: print('new file for {}'.format(t)) stock_price = si.get_live_price(t) all_dates = options.get_expiration_dates(t) new_dates_calc(all_dates, stock_price, date_today, rate, historical_loc, t) return
def DataExtraction(a,p): dates = options.get_expiration_dates(a) date = dates[p] newdate = DateConvert(date) data_chain1 = options.get_options_chain(a, newdate) for i in (data_chain1["calls"]["Contract Name"]): xlist.append("20"+i[4:10]) for i in (data_chain1["calls"]["Implied Volatility"]): ylist.append(i) for i in (data_chain1["calls"]["Strike"]): zlist.append(i)
def main2(tick): dates = options.get_expiration_dates(tick) if len(dates) == 0: print(tick + " has no dates") #m = stockMongo() #m.remove(tick) for day in dates: val = collect_options(tick, day) if not val: print("Options where note stored") print(tick)
def find_optionable_stocks(udlying): """ Check if the ticker is expired and add it to Global optional list :param udlying: Input Ticket :return: None """ global optionable_list g = options.get_expiration_dates(udlying) if len(g): print(udlying) optionable_list.append(udlying)
async def find_optoinable_stocks_async(udlying): """ Async verion of find_optionable_stocks Check if the ticker is expired and add it to Global optional list :param udlying: Input tickets :return: None """ global optionable_list g = options.get_expiration_dates(udlying) if g: print(udlying) optionable_list.append(udlying)
def get_all_calls(ticker: str) -> pd.DataFrame: dates = yo.get_expiration_dates(ticker) dates = [dt.strptime(da, c.YAHOO_DATE_FMT) for da in dates] log.info(f'Calls found for {ticker} with dates: {dates}') calls_df = pd.concat( { da: yo.get_calls(ticker=ticker, date=da).set_index('Contract Name') for da in dates }, 0, names=['Date', 'Contract Name']) return calls_df
def check(): for stock, premium in premium_stock.items(): period = 3 price = si.get_live_price(stock) print("Stock %s, price = %.2f, premium= %.2f " % (stock, price, premium)) expire_dates = ops.get_expiration_dates(stock) for date in expire_dates: period -= 1 if period < 0: break options = ops.get_options_chain(stock, date) start = price * 1.05 print( "Checking Call option for %s premium %f for range from %0.1f" % (date, premium, start)) calls = options["calls"] selected = calls.loc[(calls['Last Price'] > premium) & (calls['Strike'] > start) & (calls['Strike'] < start * 1.5)] for ind in selected.index: print( " Strike: %s %s Last: %s Bid: %s Ask: %s Volume: %s OI: %s " % (selected['Strike'][ind], selected['Contract Name'][ind], selected['Last Price'][ind], selected['Bid'][ind], selected['Ask'][ind], selected['Volume'][ind], selected['Open Interest'][ind])) start = price * 0.95 print( "Checking Put option for %s premium %f for range from %0.1f " % (date, premium, start)) puts = options["puts"] selected = puts.loc[(puts['Last Price'] > premium) & (puts['Strike'] < start) & (puts['Strike'] > start * .5)] for ind in selected.index: print( " Strike: %s %s Last: %s Bid: %s Ask: %s Volume: %s OI: %s " % (selected['Strike'][ind], selected['Contract Name'][ind], selected['Last Price'][ind], selected['Bid'][ind], selected['Ask'][ind], selected['Volume'][ind], selected['Open Interest'][ind]))
def getOptions(ticker): dates = options.get_expiration_dates( ticker) # get available expiration dates calls = {} puts = {} for date in dates: # pull and format data if (parse(date) - datetime.now()).days > 60 and ( parse(date) - datetime.now()).days < 150: print(date) calls[date] = options.get_options_chain(ticker)['calls'].set_index( 'Strike') puts[date] = options.get_options_chain(ticker)['puts'].set_index( 'Strike') return {'calls': calls, 'puts': puts}
def main(): print("getting symbols") m = stockMongo() symbols = m.get_symbols() tickers = [] for sym in symbols: tickers.append(sym['sym']) print("running data collection") for tick in tickers: dates = options.get_expiration_dates(tick) if len(dates) == 0: m = stockMongo() #m.remove(tick) for day in dates: collect_options(tick, day)
def update(self, new_ticker, rate): old_ticker = self.ticker self.risk_free_rate = rate / 100 self.ticker = new_ticker.upper() if (self.ticker != '') & (new_ticker != old_ticker): self.current_price = si.get_live_price(self.ticker) self.todays_times = [ datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S")[11:] ] self.prices_today = [si.get_live_price(self.ticker)] self.historical = si.get_data(self.ticker) self.option_dates = options.get_expiration_dates(new_ticker) self.observed_options = {} try: self.stats = si.get_stats(self.ticker).to_dict('records') except ValueError: self.stats = [{ 'Attribute': 'none available', 'Value': 'none available' }]
def expiries(ticker): ''' Gets all maturities for options on a desired stock Inputs: ticker: (str) Stock or ETF ticker symbol Returns: expiries: (list) List of all maturities ''' expiries = options.get_expiration_dates(ticker) expiries = [x.replace(',', "") for x in expiries] for i, date in enumerate(expiries): m, d, y = date.split(" ") if len(d) == 1: d = "0" + d date = " ".join([m, d, y]) t = time.strptime(date, "%B %d %Y") m, d, y = str(t.tm_mon), str(t.tm_mday), str(t.tm_year) if len(m) == 1: m = "0" + m if len(d) == 1: d = "0" + d date = "-".join([y, m, d]) expiries[i] = date return expiries
def get_exp_date(ticker): exp_date = options.get_expiration_dates(ticker) print(exp_date) return exp_date
def populate_dates(ticker): all_dates = options.get_expiration_dates(ticker) dates = [] for date in all_dates: dates.append({'label': date, 'value': date}) return dates
all = sp500 + nasdaq + dow # remove below line if you uncomment above # random_ticker = "T" # setting random strike price to inital value 0 random_strike_price = 0 # exp_dates = [] random_ticker = "" # random_ticker = random.choice(all) # exp_dates = options.get_expiration_dates(random_ticker) # get expiration dates, rerun of randomly chosen stock does not have options while True: random_ticker = random.choice(all) exp_dates = options.get_expiration_dates(random_ticker) if (len(exp_dates) != 0): break # print("\n" + str(exp_dates)) random_date = random.choice(exp_dates) # get current price, will be used to make OTM call/put calculation current_price = si.get_live_price(random_ticker) # randomly select calls or puts random_option_type = random.choice(["Call", "Put"]) if (random_option_type == "Call"): # random OTM call strike price random_strike_price = round( random.uniform(current_price, current_price *
# CALL Option: Right but not obligation to BUY a certain asset up to a certain date. # PUT Option: Right but not obligation to SELL a certain asset up to a certain date. from yahoo_fin import options import pandas as pd stock = 'MSFT' # Selected Stock Ticker print(f'All Expiration Dates for {stock}: ') print(options.get_expiration_dates(stock)) # Get all possible expiration dates print('\n') pd.set_option('display.max_columns', None) # View all columns chain = options.get_options_chain( stock, 'August 20, 2021') # Give all options that expire before a particular date #print(chain) # All Options #print('\n') print('CALL Options: \n') print(chain['calls']) # CALL Options print('\n') print('PUT Options: \n') print(chain['puts']) # PUT Options print('\n') # Another way to get call and put options directly chain = options.get_calls(stock, 'August 20, 2021') #print(chain) # Strike value depends on Stock's price, so modify as per requirement. print('CALL Options: Strike <=150 \n')
'open_interest', 'last_trade_date', 'last_trade_days' ] column_order = [ 'ul_price', 'days', 'put_call', 'strike', 'opt_price', 'opt_timeval', 'opt_innerval', 'beven_price', 'beven_pct', 'yield_max', 'yield_pa', 'ul_ymax', 'imp_vola', 'opt_pr_pct' ] # ----------------- # main part # ----------------- ul_price = si.get_live_price(symbol).round(1) # get option chain first l = options.get_expiration_dates(symbol) count = 0 df = pd.DataFrame() # extract option chains by expiration dates for x in l: count = count + 1 if count >= 0 and count <= 100: df_calls = pd.DataFrame() df_puts = pd.DataFrame() try: expiration = datetime.strptime(x, "%B %d, %Y").strftime('%d/%m/%Y') da = options.get_options_chain(symbol, expiration) df_calls = df_calls.append(pd.DataFrame(da['calls']), ignore_index=True)
def getOptionExpirationDates(ticker): expireyLst = options.get_expiration_dates(ticker) return expireyLst
# 1: Target Delta targetDelta = st.number_input("What is your target portfolio delta?", 1) # 2: Reduce/Increase/Neutralize exposure reqDelta = (targetDelta * 100) - portfolioBWD exposString = "No action required" if (reqDelta < 0): exposString = "Reduce Exposure; Buy Puts of delta:" + str(reqDelta) if (reqDelta > 0): exposString = "Add Exposure; Buy Calls of delta:" + str(reqDelta) # 3: Expiry dates # options import to find all expiry dates benchMarkExpDate = options.get_expiration_dates(benchmark) #stockExpirationDict = {} st.write("Select hedge dates: ") expDates = options.get_expiration_dates(benchmark) #bestExpDates = find_closed_exp_dates(int(hedgeDay), int(hedgeMonth), int(hedgeYear), expDates, 3) currentStr = "Select hedge date: " #actualHedgeDate = st.radio(currentStr, bestExpDates) actualHedgeDate = st.radio(currentStr, expDates) # 4: correct option type for stock in list: if (reqDelta < 0): optionType = 'puts' elif (reqDelta > 0): optionType = 'calls' else:
import pandas #expiration_dates = ops.get_expiration_dates("aapl") #print(expiration_dates) #index(['Contract Name', 'Last Trade Date', 'Strike', 'Last Price', 'Bid', # 'Ask', 'Change', '% Change', 'Volume', 'Open Interest', # 'Implied Volatility'], # dtype='object') #stocks = ["sq", "amd", "dis", "v"] stocks = ["aapl", "nflx", "nvda", "tsla", "sq", "intc", "arkk", "tsm", "v"] for s in stocks: period = 2 p = si.get_live_price(s) print ("Stock %s, price = %.2f"%(s,p)) expire_dates = ops.get_expiration_dates(s) for date in expire_dates: period -= 1 if period < 0: break premium = int (p/100) + 0.5 options = ops.get_options_chain(s, date) start = p*1.05 end = p*1.3 print ("Checking Call option for %s premium %f for range %0.1f - %0.1f"%(date, premium, start,end )) calls = options["calls"] selected = calls.loc[(calls['Last Price']> premium ) & (calls['Strike']> start) & (calls['Strike']< end) ] for ind in selected.index:
import datetime as dt import matplotlib.pyplot as plt from matplotlib import style import pandas as pd import pandas_datareader.data as web import robin_stocks as rh import json import userFunctions as uf import rhorders as rho from yahoo_fin import options from yahoo_fin import stock_info as si spy_tickers = si.tickers_sp500() spy_tickers.append('SPY') spy_tickers.append('TLT') print(spy_tickers) # scrape the options data for each Dow ticker spy_data = {} for ticker in spy_tickers: ticker_dates = options.get_expiration_dates(ticker) info = {} for date in ticker_dates: info[date] = options.get_options_chain(ticker) pd.DataFrame.to_csv('{}{}.csv'.format(ticker, date))
def GetDates(ticker): exp_dates = options.get_expiration_dates(ticker) return pd.DataFrame(exp_dates)
from yahoo_fin import options import pandas as pd import sys if __name__ == '__main__': STOCK = sys.argv[1] with pd.ExcelWriter(STOCK + ".xlsx") as writer: for date in options.get_expiration_dates(STOCK): options_at_expiry = options.get_options_chain(STOCK, date) options_at_expiry["calls"].to_excel(writer, sheet_name=date + " calls") options_at_expiry["puts"].to_excel(writer, sheet_name=date + " puts")
def extract_save_option_data(ticker): """ Imports and saves from the yahoo finance database a company's option data. The option data is split per type (call or put), expiration date, and day. It does: 1. Checks for nested directories: <ticker>\options_data_<ticker>\<expiration_date>_<ticker>_<options> Creates it if non-existent. 2. Checks in the folder for a file named: <expiration_date>_<ticker>_<calls/puts>_as-at_<date_extract> If so: merges the existing and newly extracted data. 3. Saves the data (merged when applicable) in the folder under the company's ticker. -------- :param <ticker>: String ; ticker of a company traded on the financial markets """ extract_dates = options.get_expiration_dates(ticker) today = datetime.today().strftime("%Y-%m-%d") for expiration_date in extract_dates: format_date = arrow.get(expiration_date, 'MMMM D, YYYY').format('YYYY-MM-DD') extract_date = arrow.get(expiration_date, 'MMMM D, YYYY').format('MM/DD/YYYY') try: extract = options.get_options_chain(ticker, extract_date) path = ticker + "\\options_data_" + ticker + "\\" + format_date + "_" + ticker + "_options" option_types = ["calls", "puts"] for option in option_types: extract_chain = extract[option] extract_chain = extract_chain.to_dict(orient="index") data_file_name = format_date + "_" + ticker + "_" + option + "_as-at_" + today # Step 1 if not os.path.exists(path): os.makedirs(path) # Step 2 if os.path.isfile(os.path.join(path, data_file_name)) == True: try: with open(os.path.join(path, data_file_name), 'r') as file: existing_data_in_file = json.load(file) for item in existing_data_in_file: extract_chain[item] = existing_data_in_file[ item] except Exception as e: print(f"{ticker}: {e}") #Step 3 with open(os.path.join(path, data_file_name), 'w') as f: json.dump(extract_chain, f) print( f"{ticker}: {format_date} {option} options data retrieved successfully!\n" ) except Exception as e: print( f"{ticker}: {format_date} options data could not be retrieved.\n" )