def calculate_ps_metrics(stock): yahoo_stock = YahooFinancials(stock.symbol) market_cup = yahoo_stock.get_market_cap() if stock.target_avg_sales: multiplier = FilteredStocks.get_multiplier( stock.target_avg_sales[-1]) target_avg_sales = float(stock.target_avg_sales[:-1]) * multiplier try: stock.price_to_sell_ratio = round( market_cup / target_avg_sales, 2) stock.ps_to_growth_ratio = round( stock.price_to_sell_ratio / float(stock.target_sales_growth[:-1]), 2) ev = (yahoo_stock.get_key_statistics_data()[stock.symbol] ["enterpriseValue"]) profit_margins = (yahoo_stock.get_key_statistics_data()[ stock.symbol]["profitMargins"]) stock.ev_to_sell_ratio = round(ev / target_avg_sales, 2) stock.gross_margins = round( yahoo_stock.get_gross_profit() / yahoo_stock.get_total_revenue() * 100, 2) ev_to_profit_ratio = round( stock.ev_to_sell_ratio / profit_margins, 2) print("gross_margins : " + str(stock.gross_margins)) print("ev sells : " + str(stock.ev_to_sell_ratio)) print("ev / earnings : " + str(ev_to_profit_ratio)) print("ps_to_growth : " + str(stock.ps_to_growth_ratio)) print("sales targets:" + str(stock.target_sales_growth[:-1])) print("growth adujsted ev / sells: " + str( round( stock.ev_to_sell_ratio / float(stock.target_sales_growth[:-1]), 2))) except Exception as e: print(str(e))
def fundamentals(tickers, begin="2020-05-26", end="2020-06-26",): format_header = '{:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>10} {:>10}' format_numbers = '{:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>6} {:>10.2e} {:>10.2E}' print(format_header.format('ticker', 'P/E', 'EARNSH', 'BK/PR', 'DY', 'DR', 'VAR', 'PEG', 'PS', 'PCI', 'VOLPR', 'CM',)) for ticker in tickers: yf = YF(ticker) try: pe = get_number_for_None(get_number_for_None(yf.get_pe_ratio())) prices = yf.get_historical_price_data(begin, end, "daily")[ticker]['prices'] stat_pr = calc_statistics(prices) var_pr = get_number_for_None(100 * stat_pr[1] / stat_pr[0]) volume = get_number_for_None(stat_pr[4]) es = get_number_for_None(yf.get_earnings_per_share()) sh = get_number_for_None(yf.get_num_shares_outstanding(price_type='current')) ''' "pegRatio" "priceToBook" "heldPercentInstitutions" ''' statistics = yf.get_key_statistics_data()[ticker] summary = yf.get_summary_data()[ticker] peg = get_number_for_None(statistics["pegRatio"]) PCI = get_number_for_None(statistics["heldPercentInstitutions"]) bv = yf.get_key_statistics_data()[ticker]['bookValue'] pr = yf.get_current_price() if pr is not None and bv is not None: pr_bv = get_number_for_None(pr/bv) else: pr_bv = '-99.99' f_s = yf.get_financial_stmts('annual', 'income')['incomeStatementHistory'][ticker][0] f_s_key = list(f_s.keys())[0] totalRevenue = f_s[f_s_key]['totalRevenue'] outstanding = statistics["sharesOutstanding"] rev_per_share = totalRevenue / outstanding if pr is not None and es is not None: p_s = get_number_for_None(rev_per_share/float(es)) else: p_s = '99' dy = get_number_for_None(yf.get_dividend_yield()) dr = get_number_for_None(yf.get_dividend_rate()) volume10days = summary['averageVolume10days'] marketCap = summary['marketCap'] # float(volume)*pr # float(sh)*pr) print(format_numbers.format(ticker, pe, es, pr_bv, dy, dr, var_pr, peg, p_s, PCI, volume10days, marketCap)) except Exception as e: print(ticker, e)
def get_df_1(ticker): yahoo_financials = YahooFinancials(ticker) stats_1 = yahoo_financials.get_key_statistics_data() df_1 = pd.DataFrame(stats_1).loc[['enterpriseValue'], :].transpose() df_1['marketCap'] = [yahoo_financials.get_market_cap()] return df_1
def __init__(self, ticker, name, risk_free_return): yf_stock = YF(ticker) yf_stats = si.get_stats(ticker) key_statistics = yf_stock.get_key_statistics_data() self.ticker = ticker self.name = name self.risk_free_return = risk_free_return self.beta = self.get_beta(yf_stock, yf_stats) self.wacc = self.get_wacc(yf_stock) self.growth_estimate_per_annum = self.get_growth_estimate_per_annum() self.conservative_growth_rate = self.get_conservative_growth_rate() self.recommendation_rating = self.get_recommendation_rating() self.free_cash_flow = self.get_free_cash_flow() self.price = round(si.get_live_price(ticker), 2) self.shares_outstanding = float( round(key_statistics[self.ticker]['sharesOutstanding'] / 1000000, 2)) self.profit_margin = yf_stats["Value"][30] self.operating_margin = yf_stats["Value"][31] self.return_on_assets = yf_stats["Value"][32] self.return_on_equity = yf_stats["Value"][33] self.book_value = yf_stats["Value"][47] self.quarterly_revenue_growth_yoy = yf_stats["Value"][36] self.cash = yf_stats["Value"][42] self.trailing_pe = self.get_trailing_pe(yf_stock) self.price_per_book = round(self.price / float(self.book_value), 2) self.cash_and_cash_equivalents = float( re.sub("[^\d\.\-]", "", self.cash)) * 1000 self.total_liabilities = self.get_total_liabilities(yf_stock) self.intrinsic_value = self.get_intrinsic_value() self.potential_upside = self.get_potential_upside() self.trailing_pe_pb_multiple = round( self.trailing_pe * self.price_per_book, 2)
def getMarketData(): tickers = 'AAPL' financials = YahooFinancials(tickers) # company_stock_price = financials.get_stock_price_data() #gets stock price information historical_stock_prices_data = financials.get_historical_price_data( '2015-11-21', '2020-11-21', 'daily') #gets historical daily stock price of company # get_Div_data(historical_stock_prices_data[tickers]) get_stock_price_data(historical_stock_prices_data[tickers]) # company_balance_sheet_data_qt = financials.get_financial_stmts('quarterly', 'balance') #get balance sheet # company_income_statement_data_qt = financials.get_financial_stmts('quarterly', 'income') #get income statement company_key_statistics_data = financials.get_key_statistics_data( ) #includes profit margins, forward eps, yearly change etc. # get_forward_pe(company_key_statistics_data[tickers]) # get_trailing_eps(company_key_statistics_data[tickers]) # get_foward_eps(company_key_statistics_data[tickers]) # get_ytdReturn(company_key_statistics_data[tickers]) company_earnings_data = financials.get_stock_earnings_data( ) #historical eps only for 1 year span # get_earnings_data(company_earnings_data[tickers]) company_dividend_yield = financials.get_dividend_yield( ) #current dividends yield company_dividend = financials.get_dividend_rate() #current dividends rate company_avg_div_yield_1year = financials.get_annual_avg_div_yield( ) #average 1 year div yield company_avg_div_yield_5year = financials.get_five_yr_avg_div_yield( ) #average 5 year div yield company_eps = financials.get_earnings_per_share() #current eps company_pe = financials.get_pe_ratio() #current pe ratio company_beta = financials.get_beta() #current beta company_current_stock_price = financials.get_current_price( ) #current stock price company_revenue = financials.get_total_revenue() #current company revenue company_operating_income = financials.get_operating_income( ) #current company operating income company_net_income = financials.get_net_income() #current net income company_yearly_high = financials.get_yearly_high() #get yearly high company_yearly_low = financials.get_yearly_low() #get yearly low company_moving_50 = financials.get_50day_moving_avg( ) #50 day moving average of stock company_moving_200 = financials.get_200day_moving_avg( ) #200 day moving average of stock
def get(self, ticker: str) -> asset_returns: try: ticker = ticker.upper() yf = YahooFinancials(ticker) quote_type_data = yf.get_stock_quote_type_data() # This one seems very slow key_stats = yf.get_key_statistics_data() return json.dumps({ 'ticker': ticker, 'quote_type_data': quote_type_data[ticker], 'key_stats': key_stats[ticker] }) except Exception as e: return {'message': 'Unable to retrive prices'}, 500
def get_stock_data(stock_data): symbol = stock_data['symbol'] start = time.time() print('start: {}'.format(symbol)) Stock = YahooFinancials(symbol) stock_data['pe_ratio'] = Stock.get_pe_ratio() if stock_data['pe_ratio'] != None and stock_data['pe_ratio'] < 15: key_stock_data = Stock.get_key_statistics_data() stock_data['pb_ratio'] = key_stock_data[symbol]['priceToBook'] if stock_data['pb_ratio'] != None and stock_data['pb_ratio'] < 1.5: balance_sheet_data = Stock.get_financial_stmts('annual', 'balance') income_sheet_data = Stock.get_financial_stmts('annual', 'income') bal1 = balance_sheet_data['balanceSheetHistory'][symbol][0] bal2 = balance_sheet_data['balanceSheetHistory'][symbol][1] bal3 = balance_sheet_data['balanceSheetHistory'][symbol][2] bal4 = balance_sheet_data['balanceSheetHistory'][symbol][3] bal1_key1 = next(iter(bal1)) bal2_key1 = next(iter(bal2)) bal3_key1 = next(iter(bal3)) bal4_key1 = next(iter(bal4)) inc1 = income_sheet_data['incomeStatementHistory'][symbol][0] inc2 = income_sheet_data['incomeStatementHistory'][symbol][1] inc3 = income_sheet_data['incomeStatementHistory'][symbol][2] inc4 = income_sheet_data['incomeStatementHistory'][symbol][3] inc1_key1 = next(iter(inc1)) inc2_key1 = next(iter(inc2)) inc3_key1 = next(iter(inc3)) inc4_key1 = next(iter(inc4)) stock_data['liabilities'] = bal1[bal1_key1][ 'totalCurrentLiabilities'] stock_data['assets'] = bal1[bal1_key1]['totalCurrentAssets'] stock_data['equity1'] = bal1[bal1_key1]['totalStockholderEquity'] stock_data['equity2'] = bal2[bal2_key1]['totalStockholderEquity'] stock_data['equity3'] = bal3[bal3_key1]['totalStockholderEquity'] stock_data['equity4'] = bal4[bal4_key1]['totalStockholderEquity'] stock_data['net_income1'] = inc1[inc1_key1]['netIncome'] stock_data['net_income2'] = inc2[inc2_key1]['netIncome'] stock_data['net_income3'] = inc3[inc3_key1]['netIncome'] stock_data['net_income4'] = inc4[inc4_key1]['netIncome'] db = sqlite3.connect('stocks.db') c = db.cursor() c.execute( '''INSERT INTO stocks ( symbol, company_name, pb_ratio, pe_ratio, assets, liabilities, net_income1, net_income2, net_income3, net_income4, equity1, equity2, equity3, equity4 ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)''', (stock_data['symbol'], stock_data['company_name'], stock_data['pb_ratio'], stock_data['pe_ratio'], stock_data['assets'], stock_data['liabilities'], stock_data['net_income1'], stock_data['net_income2'], stock_data['net_income3'], stock_data['net_income4'], stock_data['equity1'], stock_data['equity2'], stock_data['equity3'], stock_data['equity4'])) db.commit() del stock_data end = time.time() print('got: {} - {}'.format(symbol, round(end - start))) return None
import pandas as pd import yfinance as yf from yahoofinancials import YahooFinancials yahoo_financials = YahooFinancials('MMM') print(yahoo_financials.get_key_statistics_data()) #assets = ['TSLA', 'MSFT', 'FB'] # #yahoo_financials = YahooFinancials('BTC-USD') # ##data = yahoo_financials.get_summary_data() #data = yahoo_financials.get_key_statistics_data() ##get_historical_price_data(start_date='2019-01-01', ## end_date='2019-12-31', ## time_interval='weekly') ## ##prices_df = pd.DataFrame({ ## a: {x['formatted_date']: x['adjclose'] for x in data[a]['prices']} for a in assets ##}) #print(data)
class Company(object): def __init__(self, ticker): self.ticker = ticker.upper() self.financials = YahooFinancials(ticker) self.timeframe = 'annual' self.balance_sheet = None self.income_statement = None self.cash_flow_statement = None self.key_statistics = None self.historical_eps = None self.price_data = None self.new_corporate_tax_rate = 0.21 self.old_corporate_tax_rate = 0.35 self.risk_free_ror = 0.025 self.market_ror = 0.098 def __set_balance_sheet(self): if str(type(self.balance_sheet)) == "<class 'NoneType'>": try: self.balance_sheet = self.financials.get_financial_stmts( self.timeframe, 'balance')['balanceSheetHistory'][self.ticker] self.balance_sheet = self.__clean_statement_timestamp( self.balance_sheet) except: return None def __set_income_statement(self): if str(type(self.income_statement)) == "<class 'NoneType'>": try: self.income_statement = self.financials.get_financial_stmts( self.timeframe, 'income')['incomeStatementHistory'][self.ticker] self.income_statement = self.__clean_statement_timestamp( self.income_statement) except: return None def __set_cash_flow_statement(self): if str(type(self.cash_flow_statement)) == "<class 'NoneType'>": try: self.cash_flow_statement = self.financials.get_financial_stmts( self.timeframe, 'cash')['cashflowStatementHistory'][self.ticker] self.cash_flow_statement = self.__clean_statement_timestamp( self.cash_flow_statement) except: return None def __set_key_statistics(self): if str(type(self.key_statistics)) == "<class 'NoneType'>": try: self.key_statistics = self.financials.get_key_statistics_data() except: return None def __set_historical_eps(self): if str(type(self.historical_eps)) == "<class 'NoneType'>": url = 'https://www.nasdaq.com/earnings/report/{}'.format( self.ticker) page = requests.get(url) if page.status_code == 200: soup = BeautifulSoup(page.text, 'html.parser') eps_list = [] td = soup.find_all('td') counter = 0 for i in td[2::5]: try: test = float(i.get_text()) counter += 1 except: break for i in range(counter * 5): eps_list.append(list(soup.find_all('td'))[i].get_text()) self.historical_eps = pd.DataFrame({ 'textdate': eps_list[0::5], 'timestamp': eps_list[1::5], 'eps': eps_list[2::5], 'consensus_eps': eps_list[3::5], 'surprise': eps_list[4::5] }) self.historical_eps = self.historical_eps.iloc[::-1] self.historical_eps.reset_index(inplace=True, drop=True) else: return None def __set_price_data(self): if str(type(self.price_data)) == "<class 'NoneType'>": try: self.price_data = pd.DataFrame( self.financials.get_historical_price_data( '1800-01-01', str(datetime.now())[:10], 'daily')[self.ticker]['prices']) except: pass def __clean_statement_timestamp(self, statement): for i in statement: for j in i.keys(): i[j[:4]] = i.pop(j) return statement def __get_specific_year(self, statement, year): for i in statement: if str(list(i.keys())[0]) == str(year): return i['{}'.format(year)] def __json_to_dataframe(self, data): columns = [] for i in data: for j in i.keys(): columns.append(j) df = pd.DataFrame(data[0]) for i in range(len(columns)): df[columns[i]] = pd.DataFrame(data[i]) df = df[df.columns[::-1]] return df def set_risk_free_ror(self, risk_free_ror): self.risk_free_ror = risk_free_ror def set_market_ror(self, market_ror): self.market_ror = market_ror def check_risk_free_ror(self): return self.risk_free_ror def check_market_ror(self): return self.market_ror def check_old_corporate_tax_rate(self): return self.old_corporate_tax_rate def check_new_corporate_tax_rate(self): return self.new_corporate_tax_rate def get_balance_sheet(self): self.__set_balance_sheet() df = self.__json_to_dataframe(self.balance_sheet) return df def get_income_statement(self): self.__set_income_statement() df = self.__json_to_dataframe(self.income_statement) return df def get_cash_flow_statement(self): self.__set_cash_flow_statement() df = self.__json_to_dataframe(self.cash_flow_statement) return df def get_key_statistics(self): self.__set_key_statistics() ser = pd.Series(self.key_statistics[self.ticker]) return ser def get_historical_eps(self): self.__set_historical_eps() return self.historical_eps def get_price_data(self): self.__set_price_data() return self.price_data def check_ticker(self): return self.ticker def revenue(self, year): self.__set_income_statement() try: return self.__get_specific_year(self.income_statement, year)['totalRevenue'] except: return None def total_expenses(self, year): self.__set_income_statement() self.__set_cash_flow_statement() try: operating_expenses = self.__get_specific_year( self.income_statement, year)['totalOperatingExpenses'] interest = self.__get_specific_year(self.income_statement, year)['interestExpense'] tax = self.__get_specific_year(self.income_statement, year)['incomeTaxExpense'] depreciation = self.__get_specific_year(self.cash_flow_statement, year)['depreciation'] return abs(operating_expenses) + abs(interest) + abs(tax) + abs( depreciation) except: return None def operating_expenses(self, year): self.__set_income_statement() try: return self.__get_specific_year(self.income_statement, year)['totalOperatingExpenses'] except: return None def outstanding_shares(self): self.__set_key_statistics() try: return self.get_key_statistics()['sharesOutstanding'] except: return None def share_price(self): self.__set_price_data() try: return float(self.price_data[-1:]['close']) except: return None def market_value(self): try: return self.share_price() * self.outstanding_shares() except: return None def liquid_assets(self, year): self.__set_balance_sheet() try: return self.__get_specific_year( self.balance_sheet, year)['cash'] + self.__get_specific_year( self.balance_sheet, year)['shortTermInvestments'] except: return None def total_debt(self, year): self.__set_balance_sheet() try: return self.__get_specific_year( self.balance_sheet, year)['shortLongTermDebt'] + self.__get_specific_year( self.balance_sheet, year)['longTermDebt'] except: return None def tax(self, year): self.__set_income_statement() try: return abs( self.__get_specific_year(self.income_statement, year)['incomeTaxExpense']) except: return None def interest(self, year): self.__set_income_statement() try: return self.__get_specific_year(self.income_statement, year)['interestExpense'] except: return None def depreciation(self, year): self.__set_cash_flow_statement() try: return self.__get_specific_year(self.cash_flow_statement, year)['depreciation'] except: return None def cost_of_revenue(self, year): self.__set_income_statement() try: return self.__get_specific_year(self.income_statement, year)['costOfRevenue'] except: return None def total_receivables(self, year): self.__set_balance_sheet() try: return self.__get_specific_year(self.balance_sheet, year)['netReceivables'] except: return None def total_liabilities(self, year): self.__set_balance_sheet() try: return self.__get_specific_year(self.balance_sheet, year)['totalLiab'] except: return None def total_assets(self, year): self.__set_balance_sheet() try: return self.__get_specific_year(self.balance_sheet, year)['totalAssets'] except: return None def total_capital(self, year): self.__set_balance_sheet() try: return self.__get_specific_year( self.balance_sheet, year)['totalStockholderEquity'] + self.total_debt(year) except: return None def total_equity(self, year): try: return self.total_assets(year) - self.total_liabilities(year) except: return None def capital_expenditures(self, year): self.__set_cash_flow_statement() try: return self.__get_specific_year(self.cash_flow_statement, year)['capitalExpenditures'] except: return None def net_income(self, year): self.__set_income_statement() try: return self.__get_specific_year(self.income_statement, year)['netIncome'] except: return None def gross_profit(self, year): self.__set_income_statement() try: return self.__get_specific_year(self.income_statement, year)['grossProfit'] except: return None def earnings_per_share(self): try: return self.financials.get_earnings_per_share() except: return None def pe_ratio(self): try: return self.financials.get_pe_ratio() except: return None def enterprise_value(self): try: return self.get_key_statistics()['enterpriseValue'] except: return None def ebit(self, year): self.__set_income_statement() try: return self.__get_specific_year(self.income_statement, year)['ebit'] except: return None def ebitda(self, year): try: temp_net_income = abs(self.net_income(year)) temp_tax = abs(self.tax(year)) temp_interest = abs(self.interest(year)) temp_depreciation = abs(self.depreciation(year)) return temp_net_income + temp_tax + temp_interest + temp_depreciation except: return None def quick_ratio(self, year): try: temp_liquid_assets = abs(self.liquid_assets(year)) temp_receivables = abs(self.total_receivables(year)) temp_liabilities = abs(self.total_liabilities(year)) return (temp_liquid_assets + temp_receivables) / temp_liabilities except: return None def income_continuing_operations_margin(self, year): try: temp_ebit = self.ebit(year) temp_revenue = abs(self.revenue(year)) return temp_ebit / temp_revenue except: return None def net_margin(self, year): try: temp_net_income = self.net_income(year) temp_revenue = self.revenue(year) return temp_net_income / temp_revenue except: return None def return_on_assets(self, year): try: ending_year = year beginning_year = year - 1 temp_net_income = self.net_income(year) beginning_total_assets = abs(self.total_assets(beginning_year)) ending_total_assets = abs(self.total_assets(ending_year)) return temp_net_income / ( (beginning_total_assets + ending_total_assets) / 2) except: return None def return_on_capital(self, year): try: ending_year = year beginning_year = year - 1 if ending_year >= 2018: temp_ebit = self.ebit(year) temp_tax_rate = self.new_corporate_tax_rate beginning_total_capital = abs( self.total_capital(beginning_year)) ending_total_capital = abs(self.total_capital(ending_year)) return (temp_ebit * (1 - temp_tax_rate)) / ( (beginning_total_capital + ending_total_capital) / 2) elif ending_year < 2018: temp_ebit = self.ebit(year) temp_tax_rate = self.old_corporate_tax_rate beginning_total_capital = abs( self.total_capital(beginning_year)) ending_total_capital = abs(self.total_capital(ending_year)) return (temp_ebit * (1 - temp_tax_rate)) / ( (beginning_total_capital + ending_total_capital) / 2) except: return None def return_on_equity(self, year): try: temp_ebit = self.ebit(year) temp_total_equity = abs(self.total_equity(year)) return temp_ebit / temp_total_equity except: return None def cash_flow_operations(self, year): try: temp_revenue = abs(self.revenue(year)) temp_operating_expenses = abs(self.operating_expenses(year)) return temp_revenue - temp_operating_expenses except: return None def free_cash_flow(self, year): try: if year >= 2018: temp_cfo = self.cash_flow_operations(year) temp_interest = self.interest(year) temp_tax_rate = self.new_corporate_tax_rate temp_capex = self.capital_expenditures(year) return temp_cfo + (temp_interest * (1 - temp_tax_rate)) - temp_capex elif year < 2018: temp_cfo = self.cash_flow_operations(year) temp_interest = self.interest(year) temp_tax_rate = self.old_corporate_tax_rate temp_capex = self.capital_expenditures(year) return temp_cfo + (temp_interest * (1 - temp_tax_rate)) - temp_capex except: return None def beta(self): try: return self.financials.get_beta() except: return None def cost_of_equity(self): try: return self.risk_free_ror + ( self.beta() * (self.market_ror - self.risk_free_ror)) except: return None def gross_profit_margin(self, year): try: return (self.revenue(year) - self.cost_of_revenue(year)) / self.revenue(year) except: return None def operating_profit_margin(self, year): try: return self.ebit(year) / self.revenue(year) except: return None def net_profit_margin(self, year): try: return self.net_income(year) / self.revenue(year) except: return None def short_ratio(self): try: return self.get_key_statistics()['shortRatio'] except: return None
def get_data(): COMPANIES = ['FMC', 'GME', 'PTON', 'U'] portforlio_cmp = { "GME": { "num_shares": 2, "value": 0.0, "weight": 0.0, "beta": 0.0, "weighted_beta": 0.0 }, "FMC": { "num_shares": 8, "value": 0.0, "weight": 0.0, "beta": 0.0, "weighted_beta": 0.0 }, "U": { "num_shares": 4, "value": 0.0, "weight": 0.0, "beta": 1.16, "weighted_beta": 0.0 }, "PTON": { "num_shares": 8, "value": 0.0, "weight": 0.0, "beta": 0.31, "weighted_beta": 0.0 } } # COMPANIES = ['AAPL', 'AMZN', 'NVDA', 'TSLA'] # portforlio_cmp = { # "AAPL":{"num_shares":100, "value":0.0, "weight":0.0, "beta":0.0, "weighted_beta":0.0}, # "AMZN":{"num_shares":100, "value":0.0, "weight":0.0, "beta":0.0, "weighted_beta":0.0}, # "NVDA":{"num_shares":40, "value":0.0, "weight":0.0, "beta":0.0, "weighted_beta":0.0}, # "TSLA":{"num_shares":30, "value":0.0, "weight":0.0, "beta":0.0, "weighted_beta":0.0} # } # Set Object yfs = YahooFinancials(COMPANIES) # Set date range # today = date.today() # dta = timedelta(days=3) # prev = today - dta # d1 = today.strftime("%Y-%m-%d") # d2 = prev.strftime("%Y-%m-%d") # # maket the call print("pull stock data...") # data = yfs.get_historical_price_data(start_date=d2, # end_date=d1, # time_interval='monthly') stats_data = yfs.get_key_statistics_data() total_asset_price = 0.0 print("updating weight...") print( "------------------------------------------------------------------------------------------------------------" ) for stock in portforlio_cmp: print(stock) print("number of shares: " + str(portforlio_cmp[stock]["num_shares"])) ticker = yf.Ticker(stock) todays_data = ticker.history(period='1d') print("price: " + str(todays_data['Close'][0])) print("----------------------------------------") portforlio_cmp[stock]["value"] = todays_data['Close'][ 0] * portforlio_cmp[stock]["num_shares"] # portforlio_cmp[stock]["value"] = float(data[stock]['prices'][-1]['close']) * portforlio_cmp[stock]["num_shares"] total_asset_price += portforlio_cmp[stock]["value"] print( "------------------------------------------------------------------------------------------------------------" ) # Calculate R_f ticker = yf.Ticker('^TNX') todays_data = ticker.history(period='1d') expected_return_risk_free = todays_data['Close'][0] / 100 # update the weight portforlio_beta = 0.0 for stock in portforlio_cmp: portforlio_cmp[stock][ "weight"] = portforlio_cmp[stock]["value"] / total_asset_price print(stock + " beta: " + str(portforlio_cmp[stock]["beta"])) if stats_data[stock]['beta'] is None: portforlio_cmp[stock]["weighted_beta"] = portforlio_cmp[stock][ "weight"] * portforlio_cmp[stock]["beta"] else: portforlio_cmp[stock]["weighted_beta"] = portforlio_cmp[stock][ "weight"] * float(stats_data[stock]['beta']) portforlio_beta += portforlio_cmp[stock]["weighted_beta"] print( "------------------------------------------------------------------------------------------------------------" ) print("Portfolio Beta: " + str(portforlio_beta)) portfolio_expected_return = expected_return_risk_free + portforlio_beta * ( 0.1 - expected_return_risk_free) print("Expected Return: " + str(portfolio_expected_return))
def yahoo_data(): #ticker needs to be in ["nvda","yahoo"] format # #date needs to be in (YYYY,M,D) format start = datetime.datetime(2005, 1, 1) # We define the end date as the date from today. end = datetime.datetime.now().date() # The input for the code follows. With the while and try function the code will ask the user to enter the tickers again in case if there was an error. # The variable var is first set on 1 an changed to 0 as soon as entering the input was successful. var = 1 while (var == 1): try: # The input is converted to upperletters in case it isn't to avoid identification problems with yahoo. The string is splitted in to single elements and stored in a list. inputone = input( "Enter the tickers of four stocks, you'd like to analyze, like 'GOOG AAPL NFLX TSLA': " ) inputonesplitted = inputone.upper() tickers = inputonesplitted.split() var = 0 # If the user enters less than for tickers, he is asked to enter four of them, until he does so. while (len(tickers) < 4): inputone = input( "You entered less than four tickers. Please enter four of them: " ) inputonesplitted = inputone.upper() tickers = inputonesplitted.split() var = 0 # If the user enters more than for tickers, he is asked to enter four of them, until he does so. while (len(tickers) > 4): inputone = input( "You entered more than four tickers. Please enter four of them: " ) inputonesplitted = inputone.upper() tickers = inputonesplitted.split() var = 0 except: print("Something went wrong. Try it again!") var = 1 #Takes only the adjusted closing prices from yahoo prices = web.DataReader(tickers, "yahoo", start, end)['Adj Close'] #standardize to compare the time series #build returns. Takes all information from yahoo returns = web.DataReader(tickers, "yahoo", start, end) #daily_returns = returns['Adj Close'].pct_change() monthly_returns = returns['Adj Close'].resample('M').ffill().pct_change() #create a summary list for the stocks summary = monthly_returns.describe() summary = summary.round(3) #mean_daily_returns = daily_returns.mean() #We take from yahoo_financials all the summary data about the ticker like beta P/E ratio etc #Output is in json datastring YF = YahooFinancials(tickers) rate = YF.get_key_statistics_data() #We transform the json string to a pandas dataframe rate = pd.DataFrame(rate) #We only take certain ratios with names like beta bookValue etc from column 0 (axis=0) facts = rate.filter( { 'beta', 'bookValue', 'priceToBook', 'forwardPE', 'profitMargins', 'enterpriseToRevenue', 'enterpriseToEbitda', 'earningsQuarterlyGrowth' }, axis=0) #We make a separate variable with the enterprise values (ev) ev = rate.filter({'enterpriseValue'}, axis=0) #inc=pd.DataFrame(YF.get_financial_stmts('annual', 'balance',reformat=True)) #################### create the csv files %%%%%%%%%%%%%%%% # get relative data folder PATH = pathlib.Path(__file__).parent DATA_PATH = PATH.joinpath("./data").resolve() #Save the collected data to data folder prices.to_csv(DATA_PATH.joinpath("prices.csv")) monthly_returns.to_csv(DATA_PATH.joinpath("monthly_returns.csv")) summary.to_csv(DATA_PATH.joinpath("summary.csv")) facts.to_csv(DATA_PATH.joinpath("facts.csv")) ev.to_csv(DATA_PATH.joinpath("ev.csv"))