def update_option_plot(ticker: str, dates: list): ticker = ticker.upper() price = stock_info.get_live_price(ticker) if dates: dfs = [] for d in dates: df = options.get_calls(ticker, d) df['Expiry Date'] = d dfs.append(df) df = pd.concat(dfs) else: df = options.get_calls(ticker) df['Expiry Date'] = 'This Friday' fig = px.scatter(df, x="Strike", y="Last Price", title=ticker, size='Open Interest', color='Expiry Date', hover_data=['Open Interest', 'Implied Volatility' ]).update_traces(mode='lines+markers', marker_line_width=2) fig.add_vline(price, line_dash='dash', line_color='green', annotation_text=f'Current Stock Price: ${round(price, 2)}') fig.update_layout(plot_bgcolor=colors['background'], paper_bgcolor=colors['background'], font_color=colors['text']) return fig
def callPercentChange(ticker, strike): callChart = options.get_calls(ticker) csv = callChart.to_csv(ticker + '.csv') tickerDf = pd.read_csv(ticker + '.csv') oneRowDataframe = tickerDf.loc[tickerDf['Strike'] == strike] percentChange = oneRowDataframe.iloc[0]['% Change'] return percentChange
def calculateStopLoss(ticker, strike, optionType): if optionType == 'Call' or optionType == 'call': callChart = options.get_calls(ticker) cdf = pd.DataFrame(callChart) oneRowDataframe = cdf.loc[cdf['Strike'] == strike] ask = oneRowDataframe.iloc[0]['Ask'] bid = oneRowDataframe.iloc[0]['Bid'] currPrice = oneRowDataframe.iloc[0]['Last Price'] limitPriceUpper = (currPrice - (currPrice * .2)) - (ask - bid) limitPriceLower = (currPrice - (currPrice * .15)) - (ask - bid) if limitPriceLower < 0 or limitPriceUpper < 0: print("No need to set stop loss! This option premium is too low for a stop loss!") elif limitPriceUpper != limitPriceLower: print("Set Stop Loss Between: $", limitPriceUpper, "and $", limitPriceLower) if optionType == 'Put' or optionType == 'Put': putChart = options.get_puts(ticker) pdf = pd.DataFrame(putChart) oneRowDataframe = pdf.loc[pdf['Strike'] == strike] ask = oneRowDataframe.iloc[0]['Ask'] bid = oneRowDataframe.iloc[0]['Bid'] currPrice = oneRowDataframe.iloc[0]['Last Price'] limitPriceUpper = (currPrice - (currPrice * .2)) - (ask - bid) limitPriceLower = (currPrice - (currPrice * .15)) - (ask - bid) if limitPriceLower < 0 or limitPriceUpper < 0: print("No need to set stop loss! This option premium is too low for a stop loss!") elif limitPriceUpper != limitPriceLower: print("Set Stop Loss Between: $", limitPriceUpper, "and $", limitPriceLower)
def callVolatility(ticker, strike): callChart = options.get_calls(ticker) csv = callChart.to_csv(ticker + '.csv') tickerDf = pd.read_csv(ticker + '.csv') oneRowDataframe = tickerDf.loc[tickerDf['Strike'] == strike] volatility = oneRowDataframe.iloc[0]['Implied Volatility'] return volatility
def optimalDayTradeCall(ticker, date, type): callChart = options.get_calls(ticker, date) csv = callChart.to_csv(ticker + date + '.csv') tickerDf = pd.read_csv(ticker + date + '.csv') strikeList = tickerDf['Strike'].to_list() volumeList = tickerDf['Volume'].to_list() for i in range(len(volumeList)): if volumeList[i] == '-': volumeList[i] = int('0') #Volume Dictionary has keys as strike prices and values as volume volumeDictionary = {} keys = strikeList x = 0 for i in keys: volumeDictionary[i] = int(volumeList[x]) x += 1 gammaDictionary = {} gammalist = [] y = 0 for i in strikeList: gammalist.append(calculateGreek(ticker, date, type, i, 'gamma')) for i in keys: gammaDictionary[i] = gammalist[y] y += 1 y = 0 #print(gammaDictionary) deltaDictionary = {} deltalist = [] for i in strikeList: deltalist.append(calculateGreek(ticker, date, type, i, 'delta')) for i in keys: gammaDictionary[i] = deltalist[y] y += 1 y = 0 #print(gammaDictionary) thetadictionary = {} thetalist = [] for i in strikeList: thetalist.append(calculateGreek(ticker, date, type, i, 'theta')) for i in keys: thetadictionary[i] = thetalist[y] y += 1 y = 0 #print(thetadictionary) gammaOrderedDict = {k: v for k, v in sorted(gammaDictionary.items(), key=lambda item: item[1])} volumeOrderedDict = {k: v for k, v in sorted(volumeDictionary.items(), key=lambda item: item[1])} deltaOrderedDict = {k: v for k, v in sorted(deltaDictionary.items(), key=lambda item: item[1])} thetaOrderedDict = {k: v for k, v in sorted(thetadictionary.items(), key=lambda item: item[1])}
def update_options_list(self, option_type, strike, date): empty = { 'Last Trade Date': '', 'Strike': '', 'Last Price': '', 'Bid': '', 'Ask': '', 'Change': '', '% Change': '', 'Volume': '', 'Open Interest': '', 'Implied Volatility': '' } contract_name = option_naming(self.ticker, strike, date, option_type) orig_date = date if contract_name not in self.observed_options: #breakdown date string """ month_int = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November','December'] month_today = month_int.index(date[0:date.index(' ')])+1 date = date[date.index(' ')+1:] day_today = int(date[0:date.index(',')]) year_today = int(date[-4:]) strike_date_datetime = datetime.date(year_today, month_today, day_today) tod = datetime.date(year = datetime.datetime.today().year, month = datetime.datetime.today().month, day = datetime.datetime.today().day) years_to_maturity = (strike_date_datetime-tod).days/365 """ years_to_maturity = years_to_maturity_calc(date) #get implied volatility if option_type.lower() == 'call': df = options.get_calls(self.ticker, orig_date) else: df = options.get_puts(self.ticker, orig_date) iv = float(df.loc[df['Strike'] == strike]['Implied Volatility']. to_list()[0][0:-1].replace(',', '')) / 100 #calculate greeks grks = option_greeks(self.prices_today[-1], strike, years_to_maturity, iv, self.risk_free_rate)[option_type.lower()] #calculate prices price = round( option_price(self.prices_today[-1], strike, years_to_maturity, iv, self.risk_free_rate)[option_type.lower()], 2) opt = { 'Expir Date': orig_date, 'Strike Price': '${}'.format(strike) } opt['Value'] = '${}'.format(price) opt['Type'] = option_type opt['Implied Vol'] = '{}%'.format(np.round(iv * 100, 4)) opt.update(grks) self.observed_options[contract_name] = opt return self.observed_options
def find_spreads(ticker, date, spread_type, rr=None, pop=None): try: curr_price = math.floor(si.get_live_price(ticker)) if spread_type == 'cs': data = [] puts = options.get_puts(ticker, date) puts_filtered = puts[puts['Strike'] <= curr_price] for i in range(0, len(puts_filtered) - 1): for j in range(i + 1, len(puts_filtered)): calculate(spread_type, data, puts_filtered.iloc[i], puts_filtered.iloc[j]) df = pd.DataFrame(data, columns=[ 'Strike 1\n(LONG)', 'Strike 2\n(SHORT)', 'S1 Spread\nDiff', 'S2 Spread\nDiff', 'Net\nCredit', 'Max\nLoss', 'Max\nGain', 'Risk/Reward\nRatio', 'PoP\n(%)' ]) pd.set_option('display.max_rows', df.shape[0] + 1) if rr != None: df = df.loc[(df['Risk/Reward\nRatio'] >= float(rr))] if pop != None: df = df.loc[(df['PoP\n(%)'] >= float(pop))] # if rr == None and pop == None: # df = df.loc[(df['Risk/Reward Ratio'] >= .25) & (df['PoP (%)'] <= 99.99)] return 'No good credit spreads found. The optional filters (R/R & PoP) may be too strict' if df.empty else df # .sort_values(by='Risk/Reward', ascending=False) elif spread_type == 'ds': data = [] calls = options.get_calls(ticker, date) calls_filtered = calls[calls['Strike'] >= curr_price] for i in range(0, len(calls_filtered) - 1): for j in range(i + 1, len(calls_filtered)): calculate(spread_type, data, calls_filtered.iloc[i], calls_filtered.iloc[j]) df = pd.DataFrame(data, columns=[ 'Strike 1\n(LONG)', 'Strike 2\n(SHORT)', 'S1 Spread\nDiff', 'S2 Spread\nDiff', 'Net\nDebit', 'Max\nLoss', 'Max\nGain', 'Risk/Reward\nRatio', 'PoP\n(%)' ]) pd.set_option('display.max_rows', df.shape[0] + 1) if rr != None: df = df.loc[(df['Risk/Reward\nRatio'] >= float(rr))] if pop != None: df = df.loc[(df['PoP\n(%)'] >= float(pop))] # if rr == None and pop == None: # df = df.loc[(df['Risk/Reward Ratio'] >= 2) & (df['PoP (%)'] >= 20)] return 'No good debit spreads found. The optional filters (R/R & PoP) may be too strict' if df.empty else df # .sort_values(by='Risk/Reward', ascending=False) else: return 'Not a valid spread type' except AssertionError: return 'Not a valid ticker symbol' except ValueError: return 'Not a valid contract expiration date'
def calls_chain(ticka): calls = pd.DataFrame() stock_expiry_cache[ticka] = friday() while (calls.empty): try: calls = opt.get_calls(ticka, stock_expiry_cache[ticka]) except: stock_expiry_cache[ticka] = stock_expiry_cache[ticka] + \ dt.timedelta(days=7) calls['profit'] = calls['Last Price'] / calls['Strike'] return calls
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 get_chain(ticker, date=None, c_p='Call'): ''' Gets option chain from Yahoo Finance API Inputs: ticker: (str) Stock or ETF ticker symbol date: (str) Indicates maturity date for option (e.g: "2019-12-06") c_p: (str) Indicates call or put option Returns: Pandas DataFrame of option chain ''' cols = {'Implied Volatility': 'IV'} if c_p == 'Call': df = options.get_calls(ticker, date).rename(columns=cols) return df.set_index("Strike") if c_p == 'Put': df = options.get_puts(ticker, date).rename(columns=cols) return df.set_index("Strike")
def find_em(ticker, exp_date): sd = .6827 curr_price = round(si.get_live_price(ticker), 2) low = curr_price - (curr_price * (1 - sd)) high = curr_price + (curr_price * (1 - sd)) calls = options.get_calls(ticker, exp_date) calls = calls.loc[(calls['Strike'] >= low) & (calls['Strike'] <= high)] new_calls = calls['Implied Volatility'].str.replace(r'%', r'').astype('float') puts = options.get_puts(ticker, exp_date) puts = puts.loc[(puts['Strike'] >= low) & (puts['Strike'] <= high)] new_puts = puts['Implied Volatility'].str.replace(r'%', r'').astype('float') volatility = round((new_calls.mean() + new_puts.mean()) / 2, 2) d1 = datetime.today() d2 = datetime.strptime(exp_date, '%m/%d/%y') days_left = abs(d1 - d2).days + 1 em = round( si.get_live_price(ticker) * (volatility / 100) * math.sqrt(days_left / 365), 2) return 'Volatility: {}, Expected movement: -/+{}'.format(volatility, em)
# 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 * 3)) + (random.randrange(0, 51, 50) / 100) try: option_chain = options.get_calls(random_ticker, date=random_date) except: pass else: #random OTM put strike price random_strike_price = round(random.uniform( 0, current_price)) + (random.randrange(0, 51, 50) / 100) try: option_chain = options.get_puts(random_ticker, date=random_date) except: pass # make number a multiple of 5 if it's not # print(str(random.randrange(0,round(si.get_live_price(random_ticker)/3)+1,1) + random.randrange(0, 96, 5)/10)) print("Ticker: {0}\n{1}: ${2} {3}, literally can't go t**s up".format( random_ticker, random_date, str(round(random_strike_price, 2)),
async def on_message(message): print(message.content) if message.content.find("!") != -1: content = message.content.strip('!').lower().split() print(content) print(content[0]) if content[0] == "day": if content[1] == "gain": await message.channel.send( si.get_day_gainers().head(10).iloc[:, :3]) await message.channel.send( "-------------------------------------------") await message.channel.send( si.get_day_gainers().head(10).iloc[:, 4:7]) elif content[1] == "lose": await message.channel.send( si.get_day_losers().head(10).iloc[:, :3]) await message.channel.send( "-------------------------------------------") await message.channel.send( si.get_day_losers().head(10).iloc[:, 4:7]) elif content[1] == "active": await message.channel.send( si.get_day_most_active().head(10).iloc[:, :3]) await message.channel.send( "-------------------------------------------") await message.channel.send( si.get_day_most_active().head(10).iloc[:, 4:7]) elif content[0] == "crypto": await message.channel.send(si.get_top_crypto().head(10).iloc[:, :3] ) await message.channel.send( "-------------------------------------------") await message.channel.send(si.get_top_crypto().head(10).iloc[:, 4:5]) elif content[0] == "help": embedVar = discord.Embed(title="List of functioning commands", description="", colour=0x00ff00) embedVar.add_field(name="\u200b", value="!tsla\n!day gain\n!day loss", inline=True) embedVar.add_field( name="\u200b", value="!calls tlsa 03/19/2021\n!puts tlsa 03/19/2021", inline=True) await message.channel.send(embed=embedVar) elif content[0] == "calls": await message.channel.send( op.get_calls(content[1], content[2]).iloc[:, 2:8]) elif content[0] == "puts": await message.channel.send( op.get_puts(content[1], content[2]).iloc[:, 2:8]) else: temp = si.get_quote_table(content[0]) change = round(temp["Quote Price"] - temp["Previous Close"], 2) percentage = round(change / temp["Previous Close"] * 100, 2) displayQuote = str(round(temp["Quote Price"], 2)) displayChange = str(change) displayPercentage = str(percentage) displayTicker = content[0].upper() displayClose = str(round(temp["Previous Close"], 2)) dayRange = temp["Day's Range"].replace('-', '').split() dayLow = dayRange[0] dayHigh = dayRange[1] open = temp["Open"] close = temp["Previous Close"] volume = str(round(temp["Volume"] / 1000000, 2)) volume = volume + "M" avgVolume = str(round(temp["Avg. Volume"] / 1000000, 2)) avgVolume = avgVolume + "M" bid = temp["Bid"] ask = temp["Ask"] if change >= 0: rgb = 0x00ff00 displayChange = "+" + displayChange displayPercentage = "+" + displayPercentage else: rgb = 0xff0000 embedVar = discord.Embed( title= f"${displayTicker}\n${displayQuote} {displayChange} ({displayPercentage}%)", description="", colour=rgb) embedVar.add_field( name="\u200b", value= f"High: {dayHigh}\nLow: {dayLow}\n\nAsk: {ask}\nBid: {bid}", inline=True) embedVar.add_field(name="\u200b", value=f"Open: {open}\nPrev.: {close}", inline=True) embedVar.add_field( name="\u200b", value=f"Volume: {volume}\nAvg. Vol.: {avgVolume}", inline=True) await message.channel.send(embed=embedVar)
stock_corr_10d_ann = stock_corr_10d.multiply(sqrt(252))*100 stock_corr_5d = stock_returns.rolling(5).std() stock_corr_5d_ann = stock_corr_5d.multiply(sqrt(255))*100 ########################################################################################## # WEC X=$95, C=#0.35, Exp = 10/18 X = 95 exp_date = datetime(2019, 10, 18) days_to_exp = (exp_date - today).days purchase_date = datetime(2019, 6, 20) purchase_days_to_exp = (exp_date-purchase_date).days cost = 0.35 S_purchase = stock[purchase_date] calls = options.get_calls(ticker, exp_date) V_market = pd.to_numeric(calls.loc[calls['Strike']==X, 'Last Price'].iloc[0]) IV_exp_yahoo = pd.to_numeric(calls.loc[calls['Strike']==X, 'Implied Volatility'].iloc[0].rstrip('%'))/100 ##Implied Volatility - CALL #def implied_vol_call(S,X,T,r,c): # from scipy import log, exp, sqrt, stats # for i in range(20000): # sigma=0.005*(i+1) # d1=(log(S/X)+(r+sigma*sigma/2.)*T)/(sigma*sqrt(T)) # d2=d1-sigma*sqrt(T) # diff=c-(S*stats.norm.cdf(d1)-X*exp(-r*T)*stats.norm.cdf(d2)) # if abs(diff)<=0.02: # return i,sigma,diff ##implied_vol_call(40,40,0.5,.05,3.3) #implied_vol_call(90.42, 95, days_to_exp/365, 0, .96)
def Statement(): page_bg_img = ''' <style> body { background-image: url("https://images.pexels.com/photos/2748757/pexels-photo-2748757.jpeg?auto=compress&cs=tinysrgb&dpr=1&w=1000"); background-size: cover; } </style> ''' st.markdown(page_bg_img, unsafe_allow_html=True) symbols = 'https://raw.githubusercontent.com/Moly-malibu/Stocks/main/bxo_lmmS1.csv' df = pd.read_csv(symbols) ticker = st.sidebar.selectbox('Stocks by Company', (df['Symbol'])) tickerData = YahooFinancials(ticker) def get_symbol(symbol): url = "http://d.yimg.com/autoc.finance.yahoo.com/autoc?query={}®ion=1&lang=en".format( symbol) result = requests.get(url).json() for x in result['ResultSet']['Result']: if x['symbol'] == symbol: return x['name'] company_name = get_symbol(ticker.upper()) st.write("""# Analysis of """, company_name) company = yf.Ticker(ticker) # st.write(company.info) company_general = st.sidebar.checkbox("Financial Ratio") if company_general: st.markdown( "<h1 style='text-align: center; color: #002966;'>Financial Ratios</h1>", unsafe_allow_html=True) st.write('***Payout Ratio:*** ', company.info["payoutRatio"]) st.write('***Trailing Annual Dividend Yield:*** ', company.info["trailingAnnualDividendYield"]) st.write('***Dividend Rate:*** ', company.info["dividendRate"]) st.write('***Profit Margins: ***', company.info["profitMargins"]) st.write('***Peg Ratio: ***', company.info["pegRatio"]) yahoo_financials = YahooFinancials(ticker) marketcap = yahoo_financials.get_market_cap() price_to_sales = yahoo_financials.get_current_price() dividend_yield = yahoo_financials.get_dividend_yield() income_balance = si.get_income_statement(ticker) transpose_income = income_balance.transpose() balance_income = si.get_balance_sheet(ticker) transpose_balance = balance_income.transpose() st.write("""**Dividends**""", company.dividends) income = si.get_income_statement(ticker) transpose = income.transpose() interest_coverage1 = transpose['operatingIncome'] interest_coverage2 = transpose['interestExpense'] st.write( '***Interest Coverage:*** Operating Income / interest Expenses', interest_coverage1 / interest_coverage2) gross_profit_margin1 = transpose['totalRevenue'] gross_profit_margin2 = transpose['costOfRevenue'] st.write( '***Gross Profit Margin:*** Total Revenue / Gross Profit Margin', (gross_profit_margin1 - gross_profit_margin2) / gross_profit_margin1) balance = si.get_balance_sheet(ticker) transpose = balance.transpose() current_ratio1 = transpose['totalCurrentAssets'] current_ratio2 = transpose['totalCurrentLiabilities'] debt_to_assets1 = transpose['otherCurrentAssets'] debt_to_assets2 = transpose['totalAssets'] st.write('***Debit Assets:*** Total Debit / Total Assets', (debt_to_assets1 / debt_to_assets2)) debt_to_equity1 = transpose['otherCurrentAssets'] debt_to_equity2 = transpose['totalStockholderEquity'] st.write( '***Debit to Equity:*** Total Debit / Total Stock Holders Equity', (debt_to_equity1 / debt_to_equity2)) ROE1 = transpose_income['netIncome'] ROE2 = transpose_balance['totalStockholderEquity'] st.write( '***Return On Equity ROE:*** Net Income / (Total Stock Holder Equity + Total Stock Holder Equity)/2', (ROE1 / ((ROE2 + ROE2) / 2))) ROA1 = transpose_income['netIncome'] ROA2 = transpose_balance['totalAssets'] st.write('***Return On Assets:*** Net Income / Total Assets', (ROA1 / ROA2)) company_simulation = st.sidebar.checkbox("Monte Carlo Simulation") if company_simulation: st.markdown( "<h1 style='text-align: center; color: #002966;'>Monte Carlo Simulation Price</h1>", unsafe_allow_html=True) st.write( """Monte Carlo Simulation project future price for the stocks. """) yahoo_financials = YahooFinancials(ticker) price = yahoo_financials.get_current_price() st.write('***Current Price:***', price) marketcap = yahoo_financials.get_market_cap() st.write('***Market Capital***', marketcap) income_balance = si.get_income_statement(ticker) transpose_income = income_balance.transpose() revenue = transpose_income['totalRevenue'] st.write('***Price to sales:*** (Market Capital / Revenue', marketcap / revenue) price_to_earnings = transpose_income['netIncome'] st.write('***Price to Earnings:*** (Market Capital/ Net Income', marketcap / price_to_earnings) balance_income = si.get_balance_sheet(ticker) transpose_balance = balance_income.transpose() price_to_book = transpose_balance['totalStockholderEquity'] st.write('***Price to book:*** (marketcap/Total Stock Holders Equity', marketcap / price_to_book) start = st.date_input("Please enter date begin Analysis: ") price = yf.download(ticker, start=start, end=None)['Close'] returns = price.pct_change() last_price = price[-1] num_simulations = 1000 num_days = 252 num_simulations_df = pd.DataFrame() for x in range(num_simulations): count = 0 daily_vol = returns.std() price_series = [] price = last_price * (1 + np.random.normal(0, daily_vol)) price_series.append(price) for y in range(num_days): if count == 251: break price = price_series[count] * (1 + np.random.normal(0, daily_vol)) price_series.append(price) count += 1 num_simulations_df[x] = price_series fig = plt.figure() plt.title('Monte Carlo Simulation') plt.plot(num_simulations_df) plt.axhline(y=last_price, color='r', linestyle='-') plt.xlabel('Day') plt.ylabel('Price') st.set_option('deprecation.showPyplotGlobalUse', False) st.pyplot() st.write('Price Series Predict: ', num_simulations_df) # company_general = st.sidebar.checkbox("Quick_Ratio") # if company_general: # st.subheader("""**Quick Ratio**""") # balance=si.get_balance_sheet(ticker) # transpose=balance.transpose() # quick_ratio1 = transpose['otherCurrentAssets'] # quick_ratio2 = transpose['inventory'] # quick_ratio3 = transpose['otherCurrentLiab'] # quick_ratio = ((quick_ratio1-quick_ratio2)/quick_ratio3) # if not quick_ratio2: # st.write("No data available") # else: # st.write('(***Quick Ratio:*** CurrentAssets - Inventory)/Current Liabilities)', (quick_ratio1-quick_ratio2)/quick_ratio3) company_hist = st.sidebar.checkbox("Cash Flow") if company_hist: st.markdown( "<h1 style='text-align: center; color: #002966;'>Cash Flow</h1>", unsafe_allow_html=True) display_cash = si.get_cash_flow(ticker) if display_cash.empty == True: st.write("No data available") else: st.write(display_cash) company_hist = st.sidebar.checkbox("Income Statement") if company_hist: st.markdown( "<h1 style='text-align: center; color: #002966;'>Income Statement</h1>", unsafe_allow_html=True) display_income_stat = si.get_income_statement(ticker) if display_income_stat.empty == True: st.write("No data available") else: st.write(display_income_stat) company_hist = st.sidebar.checkbox("Balance Sheet") if company_hist: st.markdown( "<h1 style='text-align: center; color: #002966;'>Balance Sheet</h1>", unsafe_allow_html=True) display_balance = si.get_balance_sheet(ticker) if display_balance.empty == True: st.write("No data available") else: st.write(display_balance) company_hist = st.sidebar.checkbox("Quote Table") if company_hist: st.markdown( "<h1 style='text-align: center; color: #002966;'>Quote Table</h1>", unsafe_allow_html=True) display_table = si.get_quote_table(ticker, dict_result=False) if display_table.empty == True: st.write("No data available") else: st.write(display_table) quote_table = si.get_quote_table(ticker) t = quote_table["Forward Dividend & Yield"] st.write('Forward Dividend & Yield:', t) display_capital = si.get_quote_table(ticker)["Market Cap"] st.write('Market Capital', display_capital) company_hist = st.sidebar.checkbox("Call Option") if company_hist: st.markdown( "<h1 style='text-align: center; color: #002966;'>Call Option</h1>", unsafe_allow_html=True) c = ops.get_calls(ticker) transpose = c.transpose() st.write(transpose)
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') print(chain[chain['Strike'] <= 150] ) # Get all rows where strike price is less than 150 print('\n') chain = options.get_puts(stock, 'August 20, 2021') #print(chain) print('PUT Options: Strike <=150 \n') print(chain[chain['Strike'] <= 150] ) # Get all rows where strike price is less than 150 print('\n')
import yahoo_fin.options as ops import statistics df = ops.get_calls("ual") print(len(df["Implied Volatility"]), "calls") print("Mean σ:", statistics.mean([float(i[:-1]) for i in df["Implied Volatility"]]) / 100)