def yahoo_finance_functions():
si.get_data("AAPL")
si.get_day_gainers()
si.get_day_losers()
si.get_day_most_active()
si.get_analysts_info("AAPL")
stock = si.get_live_price("AAPL")
def add_quick_summary(self):
quick_summary_md = ""
quick_summary_md += f"# Quick summary about {self.name}\n\n"
quick_summary_md += "This is the quick summary:\n\n"
try:
status, messages, _ = self.is_good_business()
quick_summary_md += f"{self.name} is a good business? \nAnswer: {status}\n\n"
if status == False:
quick_summary_md += f"Reason:, {messages}\n\n"
except:
pass
for item in [
"sector", "longBusinessSummary", "country", "city",
"trailingPE", "priceToSalesTrailing12Months",
"fiftyTwoWeekHigh", "fiftyTwoWeekLow", "pegRatio",
"shortPercentOfFloat", "next_earnings_date"
]:
try:
tmp_str = f"- {item}: {self.attribute[item]}\n\n"
quick_summary_md += tmp_str
except:
pass
info = si.get_stats_valuation(self.name)
quick_summary_md += info.to_markdown() + "\n\n"
info = si.get_analysts_info(self.name)
quick_summary_md += info["Growth Estimates"].to_markdown() + "\n\n"
#quick_summary_md += info["Revenue Estimate"].to_markdown() + "\n\n"
# finally, add it into markdown_notes
self.markdown_notes += quick_summary_md
return quick_summary_md
def update_analyst_info(self, symbol):
analysts_info = si.get_analysts_info(symbol)
analysts_info = {'Earnings Estimate' : analysts_info['Earnings Estimate'].to_dict(orient="dict"),
'Revenue Estimate' : analysts_info['Revenue Estimate'].to_dict(orient="dict"),
'Earnings History' : analysts_info['Earnings History'].to_dict(orient="dict"),
'EPS Trend' : analysts_info['EPS Trend'].to_dict(orient="dict"),
'EPS Revisions' : analysts_info['EPS Revisions'].to_dict(orient="dict"),
'Growth Estimates' : analysts_info['Growth Estimates'].to_dict(orient="dict")}
self.update(symbol, analysts_info, 'Stocks', 'Analyst_Info')
def fair_value(ticker, years=1, wish_return=0.4):
netincome = Decimal(si.get_income_statement(ticker)[si.get_income_statement(ticker).columns[0]].netIncome)
shares_outstanding = number_encoder(str(si.get_stats(ticker)["Value"][9]))
current_eps = netincome / shares_outstanding
all_growth_rates = [Decimal(x[:-1]) for x in si.get_analysts_info(ticker)["Revenue Estimate"][
si.get_analysts_info(ticker)["Revenue Estimate"].columns[
:-2]].iloc[5][1:].dropna()]
growth_rate = sum(all_growth_rates) / len(all_growth_rates) / 100
projected_eps = current_eps * (1 + growth_rate) ** years
projected_pe_ratio = Decimal(si.get_live_price(ticker)) / projected_eps
forwarded_pe_ratio = Decimal(si.get_stats_valuation(ticker)[si.get_stats_valuation(ticker).columns[1]][2]) * (
1 + growth_rate) ** (years - 1)
return (forwarded_pe_ratio * projected_eps) / Decimal(1 + wish_return)
def analysts(request):
ticker = json.loads(request.body)['ticker']
if not ticker:
return HttpResponse('ticker not received')
else:
info = si.get_analysts_info(ticker)
#print info to a text buffer
with io.StringIO() as buf, redirect_stdout(buf):
print(info)
output = buf.getvalue()
return HttpResponse(output)
def down_anal(self, ticker):
info = si.get_analysts_info(ticker)
filename = ticker + 'AnalystInfo.txt'
f = open(filename, "x")
print(info, file=f)
def get_financial_info(ticker):
eps_history_file = os.path.join(INFO_DIR, 'eps_history.csv')
trends_file = os.path.join(INFO_DIR, 'trends.csv')
if not os.path.exists(eps_history_file):
with open(eps_history_file, 'w') as f:
f.write('Ticker,Date,Est,Actual\n')
if not os.path.exists(trends_file):
with open(trends_file, 'w') as f:
f.write(
'Ticker,EPS_Quarter,EPS_NextQuarter,EPS_Year,EPS_NextYear,Growth_Quarter,Growth_NextQuarter,Growth_Year,Growth_NextYear,Date\n'
)
earnings_df = pandas.read_csv(eps_history_file,
index_col=['Ticker', 'Date'],
parse_dates=['Date'])
trends_df = pandas.read_csv(trends_file,
index_col=['Ticker'],
parse_dates=['Date'])
if ticker not in earnings_df.index:
ignore = False
try:
Debug('Update financial info for', ticker)
info = get_analysts_info(ticker)
if ('Earnings Estimate'
in info) and ('EPS Trend' in info) and ('Growth Estimates'
in info):
eps_history = info['Earnings History']
for c in eps_history.columns[1:]:
earnings_df.loc[(ticker, pandas.to_datetime(c)), :] = [
float(eps_history[c].iloc[0]),
float(eps_history[c].iloc[1])
]
eps_trend = info['EPS Trend']
growth = info['Growth Estimates']
values = list(eps_trend.iloc[0][1:].values)
for i in range(4):
if pandas.isnull(growth.iloc[i][1]):
values.append(0)
else:
values.append(
float(growth.iloc[i][1].strip('%').replace(
',', '')))
values.append(datetime.datetime.today())
trends_df.loc[ticker, :] = values
else:
ignore = True
except:
ignore = True
if ignore:
earnings_df.loc[(ticker,
pandas.to_datetime('1975-01-01')), :] = [0, 0]
trends_df.loc[ticker, :] = [
0, 0, 0, 0, 0, 0, 0, 0,
datetime.datetime.today()
]
earnings_df.sort_index(inplace=True)
earnings_df.to_csv(eps_history_file)
trends_df.sort_index(inplace=True)
trends_df.to_csv(trends_file)
earnings_df = pandas.read_csv(eps_history_file,
index_col=['Ticker', 'Date'],
parse_dates=['Date'])
trends_df = pandas.read_csv(trends_file,
index_col=['Ticker'],
parse_dates=['Date'])
result = dict(eps=earnings_df.loc[(ticker, )][0:4],
trends=trends_df.loc[ticker])
return result
def animate(i):
xs, ys, xar, yar, ticker, Estimations = live.plotting()
xs = (xs)
ys = (ys)
# set up pandas dataframe to analyse data from
df = pd.DataFrame(columns=['Date', 'Price', 'ma'])
df['Date'] = xar
df['Price'] = yar
# calculate the rolling average for the last 50 data points
df['ma'] = df.rolling(10).mean()
x = df['ma'].tolist()
x = x[-50:]
# calculate line of best fit
xs2 = []
for i in range(len(xs)):
xs2.append(i)
xs2 = np.array(xs2, dtype=np.float64)
ys2 = np.array(ys, dtype=np.float64)
m = (((mean(xs2) * mean(ys2)) - mean(xs2 * ys2)) /
((mean(xs2) * mean(xs2)) - mean(xs2 * xs2)))
b = mean(ys2) - m * mean(xs2)
regression_line = [(m * np.int64(x)) + b for x in range(len(xs))]
if m > 0:
DIC = 'green'
elif m == 0:
DIC = 'black'
else:
DIC = 'red'
# Find and plot daily upper and lower limits
table = si.get_quote_table(ticker, dict_result=False)
limits = table.iloc[6]['value']
low, high = np.array(limits.split(' - '), dtype=np.float64)
# fetch analyst info
analyst = si.get_analysts_info(ticker)
EPS_revisions = analyst['EPS Revisions']
EPS_trend = analyst['EPS Trend']
Earnings_estimate = analyst['Earnings Estimate']
Earnings_history = analyst['Earnings History']
Growth_estimate = analyst['Growth Estimates']
Revenue_estimate = analyst['Revenue Estimate']
Growth_estimate_current = np.array(Growth_estimate.iloc[0][ticker].replace(
'%', ''),
dtype=np.float64)
Growth_estimate_future = np.array(Growth_estimate.iloc[1][ticker].replace(
'%', ''),
dtype=np.float64)
Surprise_history = np.array(Earnings_history.iloc[3][-1].replace('%', ''),
dtype=np.float64)
Earnings_estimate_low = np.array(Earnings_estimate.iloc[2][-4],
dtype=np.float64)
Earnings_estimate_high = np.array(Earnings_estimate.iloc[3][-4],
dtype=np.float64)
Growth_estimate_current = ((Growth_estimate_current / 100) + 1) * ys[-1]
Growth_estimate_future = ((Growth_estimate_future / 100) + 1) * ys[-1]
Surprise_low = ys[-1] - ((Surprise_history / 100) * ys[-1])
Earnings_estimate_high = Earnings_estimate_high * ys[-1]
Earnings_estimate_low = Earnings_estimate_low * ys[-1]
ax.clear()
ax.plot(xs, ys)
if Estimations is True:
ax3.axhline(y=low, xmin=0, xmax=1, color='orange', label='Low today')
ax3.axhline(y=high, xmin=0, xmax=1, color='orange', label='High today')
ax3.axhline(y=Growth_estimate_current,
xmin=0,
xmax=1,
color='red',
label='Groth estimate')
ax3.axhline(y=Growth_estimate_future,
xmin=0,
xmax=1,
color='red',
label='Growth estimate future')
ax3.axhline(y=Surprise_low,
xmin=0,
xmax=1,
color='blue',
label='Surprise low')
ax3.axhline(y=Earnings_estimate_high,
xmin=0,
xmax=1,
color='black',
label='Earnings estimate high')
ax3.axhline(y=Earnings_estimate_low,
xmin=0,
xmax=1,
color='black',
label='Earnings estimate low')
ax3.plot(xs, ys, color=DIC)
ax.plot(regression_line, color=DIC)
ax.plot(x)
ax2.plot(xar, yar, color=DIC)
def get_analytics(self):
if self.storage == None:
return self.format2D(stock_info.get_analysts_info(self.stock))
else:
self.storage['analytics'] = self.format2D(stock_info.get_analysts_info(self.stock))
def getAnalystsInfo(ticker):
return si.get_analysts_info(ticker)
'What is the Weighted Average Maturity of Debt Found in 10k Report (if unsure write 5):'
))
print(int(input('Stock Based Compensation:')))
Ticker = input("Insert Ticker:")
quote = yf.get_quote_table(Ticker)
# indexing market cap
MarketCap = quote["Market Cap"]
# print market cap
beta = quote["Beta (5Y Monthly)"]
print('Market Cap:', "{:,}".format(conv_mrktcap(MarketCap)), '$')
print('Beta:', beta)
stats = yf.get_stats_valuation(Ticker)
Data = yf.get_data(Ticker)
Balance_Sheet = yf.get_balance_sheet(Ticker)
financials = yf.get_financials(Ticker)
analyst = yf.get_analysts_info(Ticker)
# import company's valuations as stats
income = yf.get_income_statement(Ticker)
Cash = yf.get_cash_flow(Ticker)
# import comapny's income statement as income
ebit = income.loc["ebit"]
# indexing ebit in icnome statement
ebit2020 = int(ebit["2020"])
# indexing latest ebit in income statement
print('Latest Calender Ebit:', "{:,}".format(ebit2020), "$")
interestExpense = income.loc['interestExpense']
# indexing interest expense in imcome statement
interestExpense2020 = int(-interestExpense["2020"])
# indexing latest interest expemse in income statement
def get_analysts_info(tick):
analysts_info = yf.get_analysts_info(tick)
di = []
for i in analysts_info:
di.append(analysts_info[i].to_json())
return (jsonify(di))
dow_historical = {}
for ticker in dow_list:
dow_historical = si.get_data(ticker, start_date='1990-01-01', end_date='2020-01-01', interval='1d')
print(ticker)
print(si.get_quote_table('AAPL'))
print(si.get_stats('AAPL')[si.get_stats('AAPL')['Attribute'] == 'EBITDA']['Value'].iloc[0])
"""
all_data = {}
for ticker in {'AMZN'}:
balance_sheet = si.get_balance_sheet(ticker, False)
income_statement = si.get_income_statement(ticker, False)
cash_flow = si.get_cash_flow(ticker, False)
stats = si.get_stats(ticker)
analysts_info = si.get_analysts_info(ticker)
earnings = si.get_earnings(ticker)
oneyear_return = (si.get_data(ticker, start_date=datetime.today()-timedelta(days=365), end_date=datetime.today())['close'].iloc[-1] - si.get_data(ticker, start_date=datetime.today()-timedelta(days=365), end_date=datetime.today())['close'][0])/si.get_data(ticker, start_date=datetime.today()-timedelta(days=365), end_date=datetime.today())['close'][0]
stats.columns = ['Labels', 'Values']
stats_labels = []
stats_values = []
for i in range(stats.shape[0]):
stats_labels.append(stats.iat[i, 0])
stats_values.append(stats.iat[i, 1])
stats_df = pd.DataFrame({'Values': stats_values}, index=stats_labels)
print(analysts_info['Earnings Estimate'])
earnings_estimate = analysts_info['Earnings Estimate'].iloc[[]]
from yahoo_fin import stock_info as si import pprint as pp symbol = 'HDFCBANK.NS' print(si.get_live_price(symbol)) print(si.get_data(symbol)) pp.pprint(si.get_quote_table(symbol)) pp.pprint(si.get_stats(symbol)) pp.pprint(si.get_holders(symbol)) pp.pprint(si.get_analysts_info(symbol)) pp.pprint(si.get_income_statement(symbol)) pp.pprint(si.get_balance_sheet(symbol)) pp.pprint(si.get_cash_flow(symbol))
if input_arguments.information != '':
if input_arguments.information == 'data':
print(si.get_data(input_arguments.symbol))
elif input_arguments.information == 'quote':
pp.pprint(si.get_quote_table(input_arguments.symbol))
elif input_arguments.information == 'stats':
pp.pprint(si.get_stats(input_arguments.symbol))
elif input_arguments.information == 'holders':
pp.pprint(si.get_holders(input_arguments.symbol))
elif input_arguments.information == 'analysis':
pp.pprint(si.get_analysts_info(input_arguments.symbol))
elif input_arguments.information == 'income':
pp.pprint(si.get_income_statement(input_arguments.symbol))
elif input_arguments.information == 'balance':
pp.pprint(si.get_balance_sheet(input_arguments.symbol))
elif input_arguments.information == 'cashflow':
pp.pprint(si.get_cash_flow(input_arguments.symbol))
sys.exit()
previous_price = 0
import yahoo_fin.stock_info as info
import datetime
ticker = []
test = 'ZM'
date = datetime.date.today()
print(date)
file = open('guide/tickers.txt', 'r').readlines()
for line in file:
line = line.replace('\n', '')
ticker.append(line)
print(info.get_data(test, start_date="1/2/2018"))
print(info.get_balance_sheet(test))
print(info.get_analysts_info(test))
If growth esimates push feature values outside the range seen by the model
then the valuation will just be the highest valuation seen in the data.
<a href ="http://freerangestats.info/blog/2016/12/10/extrapolation" target="_blank">
Link for more info. </a>
</cite></small></p>
''',
unsafe_allow_html=True)
# except:
# st.error(
# 'Oops...Something Went Wrong.')
# ANALYST ESTIMATES
if analyst_growth:
st.subheader('Analyst Growth Estimates')
st.table(
si.get_analysts_info(ticker)['Growth Estimates'].set_index(
'Growth Estimates')[[ticker]].T)
# FINANCIAL STATEMENTS
if financial_statements:
st.subheader('Financial Statements')
st.markdown(f'''<p><small>
Publish Date: <code>{data['Income'][key].loc[ticker]['Publish Date']}</code>
<br>
Shares (Basic): <code>{data['Income'][key].loc[ticker]['Shares (Basic)']}</code>
</small></p>
''',
unsafe_allow_html=True)
income, balance, cashflow = st.beta_columns(3)
with income:
st.write('INCOME')
def plot_earning(self, **kwargs):
plt.figure(figsize=(12, 9))
fig, axes = plt.subplots(2)
# add earning history
earnings_history = si.get_earnings_history(self.name)
earnings_history = pd.DataFrame(earnings_history)
earnings_history.dropna(inplace=True)
earnings_history = earnings_history.set_index("startdatetime")
earnings_history = earnings_history.sort_index()
earnings_history.index = pd.to_datetime(earnings_history.index)
if len(earnings_history) > 10:
earnings_history = earnings_history.iloc[-10:]
result_dict = {}
result_dict["epsactual"] = list(earnings_history["epsactual"])
result_dict["epsestimate"] = list(earnings_history["epsestimate"])
earnings = si.get_earnings(self.name)
info = si.get_analysts_info(self.name)
result_dict["epsactual"].extend([None, None])
result_dict["epsestimate"].append(
info["Earnings Estimate"].T.iloc[1].loc[1])
result_dict["epsestimate"].append(
info["Earnings Estimate"].T.iloc[2].loc[1])
result_df = pd.DataFrame(result_dict)
this_year = dt.datetime.now().year
next_year = this_year + 1
new_row = {
"date":
this_year,
"revenue":
_convert_to_numeric(info["Revenue Estimate"].T.iloc[3].loc[1]),
#"earnings": _convert_to_numeric(info["Earnings Estimate"].T.iloc[3].loc[1])
}
earnings["yearly_revenue_earnings"] = earnings[
"yearly_revenue_earnings"].append(new_row, ignore_index=True)
new_row = {
"date":
next_year,
"revenue":
_convert_to_numeric(info["Revenue Estimate"].T.iloc[4].loc[1]),
#"earnings": _convert_to_numeric(info["Earnings Estimate"].T.iloc[4].loc[1])
}
earnings["yearly_revenue_earnings"] = earnings[
"yearly_revenue_earnings"].append(new_row, ignore_index=True)
earnings["yearly_revenue_earnings"]["revenue"] = earnings[
"yearly_revenue_earnings"]["revenue"] / 1000000000
#earnings["yearly_revenue_earnings"] = earnings["yearly_revenue_earnings"]/1000000000
earnings["yearly_revenue_earnings"].set_index('date', inplace=True)
earnings["yearly_revenue_earnings"]["revenue"].plot(
ax=axes[0], marker='o', legend=["revenue(B)"])
#print(result_df)
result_df.plot(ax=axes[1], marker='o')
# save to file if possible
#fig = plt.gcf()
image_name = self.name
if "image_name" in kwargs:
image_name = kwargs['image_name']
result_dir = kwargs['result_dir'] if 'result_dir' in kwargs else None
if result_dir is not None:
file_name = image_name + "_earnings.png"
fig.savefig(os.path.join(result_dir, file_name), dpi=300)
plt.close(fig)
self.markdown_notes += "\n\n \pagebreak\n\n"
self.markdown_notes += f"\n\n\n"
return file_name
else:
return fig, axes
def load_dataset(refresh_days=1,
dataset='general',
thresh=0.7,
simfin_api_key='free',
simfin_directory='simfin_data/',
data_directory=DATA_DIR,
shareprices_df=''):
# Set Simfin Settings
sf.set_api_key(simfin_api_key)
sf.set_data_dir(simfin_directory)
derived_shareprice_df = sf.load_derived_shareprices(variant='latest',
market='us')
derived_shareprice_df.to_csv(data_directory / 'stock_derived.csv')
company_df = sf.load_companies(market='us', refresh_days=1)
company_df.to_csv(data_directory / 'company.csv')
industry_df = sf.load_industries(refresh_days=1)
industry_df.to_csv(data_directory / 'industry.csv')
# Analyst Growth Update
try:
mtime = (DATA_DIR / 'analyst_growth_target.csv').stat().st_mtime
mtime = pd.to_datetime(datetime.datetime.fromtimestamp(mtime))
days_since_update = (pd.to_datetime('today') - mtime).days
except:
days_since_update = False
dfs = []
if days_since_update > 30 or not days_since_update:
for ticker in company_df.index:
try:
df = si.get_analysts_info(
ticker)['Growth Estimates'].set_index('Growth Estimates')[[
ticker
]].T
dfs.append(df)
except:
pass
growth_df = pd.concat(dfs)
growth_df = growth_df.applymap(lambda x: float(
x.strip('%').replace(",", "")) / 100 if pd.notnull(x) else x)
growth_df.to_csv('analyst_growth_estimates.csv')
if dataset == 'general':
# Load Data from Simfin
income_df = sf.load_income(variant='ttm',
market='us',
refresh_days=refresh_days)
income_df = income_df.sort_index(level=['Ticker', 'Report Date'],
ascending=[1, 1])
income_quarterly_df = sf.load_income(variant='quarterly',
market='us',
refresh_days=refresh_days)
income_quarterly_df = income_quarterly_df.sort_index(
level=['Ticker', 'Report Date'], ascending=[1, 1])
income_df.groupby('Ticker').last().to_csv(data_directory /
'general_income.csv')
balance_df = sf.load_balance(variant='ttm',
market='us',
refresh_days=refresh_days)
balance_df = balance_df.sort_index(level=['Ticker', 'Report Date'],
ascending=[1, 1])
balance_quarterly_df = sf.load_balance(variant='quarterly',
market='us',
refresh_days=refresh_days)
balance_quarterly_df = balance_quarterly_df.sort_index(
level=['Ticker', 'Report Date'], ascending=[1, 1])
balance_df.groupby('Ticker').last().to_csv(data_directory /
'general_balance.csv')
cashflow_df = sf.load_cashflow(variant='ttm',
market='us',
refresh_days=refresh_days)
cashflow_df = cashflow_df.sort_index(level=['Ticker', 'Report Date'],
ascending=[1, 1])
cashflow_quarterlay_df = sf.load_cashflow(variant='quarterly',
market='us',
refresh_days=refresh_days)
cashflow_quarterlay_df = cashflow_quarterlay_df.sort_index(
level=['Ticker', 'Report Date'], ascending=[1, 1])
cashflow_df.groupby('Ticker').last().to_csv(data_directory /
'general_cashflow.csv')
derived_df = sf.load_derived(variant='ttm',
market='us',
refresh_days=refresh_days)
derived_df = derived_df.sort_index(level=['Ticker', 'Report Date'],
ascending=[1, 1])
derived_df.groupby('Ticker').last().to_csv(
data_directory / 'general_fundamental_derived.csv')
cache_args = {
'cache_name': 'financial_signals',
'cache_refresh': refresh_days
}
fin_signal_df = sf.fin_signals(df_income_ttm=income_df,
df_balance_ttm=balance_df,
df_cashflow_ttm=cashflow_df,
**cache_args)
growth_signal_df = sf.growth_signals(
df_income_ttm=income_df,
df_income_qrt=income_quarterly_df,
df_balance_ttm=balance_df,
df_balance_qrt=balance_quarterly_df,
df_cashflow_ttm=cashflow_df,
df_cashflow_qrt=cashflow_quarterlay_df,
**cache_args)
# Remove Columns that exist in other Fundamental DataFrames
balance_columns = balance_df.columns[~balance_df.columns.isin(set(
).union(income_df.columns))]
cashflow_columns = cashflow_df.columns[~cashflow_df.columns.isin(set(
).union(income_df.columns))]
derived_df_columns = derived_df.columns[~derived_df.columns.isin(set(
).union(income_df.columns, growth_signal_df.columns, fin_signal_df.
columns))]
# Merge the fundamental data into a single dataframe
fundamental_df = income_df.join(balance_df[balance_columns]).join(
cashflow_df[cashflow_columns]).join(fin_signal_df).join(
growth_signal_df).join(derived_df[derived_df_columns])
fundamental_df['Dataset'] = 'general'
elif dataset == 'banks':
# Load Data from Simfin
income_df = sf.load_income_banks(variant='ttm',
market='us',
refresh_days=refresh_days)
income_df = income_df.sort_index(level=['Ticker', 'Report Date'],
ascending=[1, 1])
income_df.groupby('Ticker').last().to_csv(data_directory /
'banks_income.csv')
balance_df = sf.load_balance_banks(variant='ttm',
market='us',
refresh_days=refresh_days)
balance_df = balance_df.sort_index(level=['Ticker', 'Report Date'],
ascending=[1, 1])
balance_df.groupby('Ticker').last().to_csv(data_directory /
'banks_balance.csv')
cashflow_df = sf.load_cashflow_banks(variant='ttm',
market='us',
refresh_days=refresh_days)
cashflow_df = cashflow_df.sort_index(level=['Ticker', 'Report Date'],
ascending=[1, 1])
cashflow_df.groupby('Ticker').last().to_csv(data_directory /
'banks_cashflow.csv')
derived_df = sf.load_derived_banks(variant='ttm',
market='us',
refresh_days=refresh_days)
derived_df = derived_df.sort_index(level=['Ticker', 'Report Date'],
ascending=[1, 1])
derived_df.groupby('Ticker').last().to_csv(
data_directory / 'banks_fundamental_derived.csv')
derived_df.groupby('Ticker').last().to_csv(
data_directory / 'banks_fundamental_derived.csv')
# Remove Columns that exist in other Fundamental DataFrames
balance_columns = balance_df.columns[~balance_df.columns.isin(set(
).union(income_df.columns))]
cashflow_columns = cashflow_df.columns[~cashflow_df.columns.isin(set(
).union(income_df.columns))]
derived_df_columns = derived_df.columns[~derived_df.columns.isin(set(
).union(income_df.columns))]
# Merge the fundamental data into a single dataframe
fundamental_df = income_df.join(balance_df[balance_columns]).join(
cashflow_df[cashflow_columns]).join(derived_df[derived_df_columns])
fundamental_df['Dataset'] = 'banks'
elif dataset == 'insurance':
# Load Data from Simfin
income_df = sf.load_income_insurance(variant='ttm',
market='us',
refresh_days=refresh_days)
income_df = income_df.sort_index(level=['Ticker', 'Report Date'],
ascending=[1, 1])
income_df.groupby('Ticker').last().to_csv(data_directory /
'insurance_income.csv')
balance_df = sf.load_balance_insurance(variant='ttm',
market='us',
refresh_days=refresh_days)
balance_df = balance_df.sort_index(level=['Ticker', 'Report Date'],
ascending=[1, 1])
balance_df.groupby('Ticker').last().to_csv(data_directory /
'insurance_balance.csv')
cashflow_df = sf.load_cashflow_insurance(variant='ttm',
market='us',
refresh_days=refresh_days)
cashflow_df = cashflow_df.sort_index(level=['Ticker', 'Report Date'],
ascending=[1, 1])
cashflow_df.groupby('Ticker').last().to_csv(data_directory /
'insurance_cashflow.csv')
derived_df = sf.load_derived_insurance(variant='ttm',
market='us',
refresh_days=refresh_days)
derived_df = derived_df.sort_index(level=['Ticker', 'Report Date'],
ascending=[1, 1])
derived_df.groupby('Ticker').last().to_csv(
data_directory / 'insurance_fundamental_derived.csv')
# Remove Columns that exist in other Fundamental DataFrames
balance_columns = balance_df.columns[~balance_df.columns.isin(set(
).union(income_df.columns))]
cashflow_columns = cashflow_df.columns[~cashflow_df.columns.isin(set(
).union(income_df.columns))]
derived_df_columns = derived_df.columns[~derived_df.columns.isin(set(
).union(income_df.columns))]
# Merge the fundamental data into a single dataframe
fundamental_df = income_df.join(balance_df[balance_columns]).join(
cashflow_df[cashflow_columns]).join(derived_df[derived_df_columns])
fundamental_df['Dataset'] = 'insurance'
# Drop Columns with more then 1-thresh nan values
fundamental_df = fundamental_df.dropna(thresh=int(thresh *
len(fundamental_df)),
axis=1)
# Drop Duplicate Index
fundamental_df = fundamental_df[~fundamental_df.index.duplicated(
keep='first')]
# Replace Report Date with the Publish Date because the Publish Date is when the Fundamentals are known to the Public
fundamental_df['Published Date'] = fundamental_df['Publish Date']
fundamental_df = fundamental_df.reset_index().set_index(
['Ticker', 'Publish Date'])
df = sf.reindex(df_src=fundamental_df,
df_target=shareprices_df,
group_index=TICKER,
method='ffill').dropna(how='all').join(shareprices_df)
# General
# Clean Up
df = df.drop([
'SimFinId', 'Currency', 'Fiscal Year', 'Report Date', 'Restated Date',
'Fiscal Period', 'Published Date'
],
axis=1)
if dataset == 'general':
# Remove Share Prices Over Amazon Share Price
df = df[df['Close'] <= df.loc['AMZN']['Close'].max()]
df = df.dropna(subset=[
'Shares (Basic)', 'Shares (Diluted)', 'Revenue', 'Earnings Growth'
])
non_per_share_cols = [
'Currency', 'Fiscal Year', 'Fiscal Period', 'Published Date',
'Restated Date', 'Shares (Basic)', 'Shares (Diluted)', 'Close',
'Dataset'
] + fin_signal_df.columns.tolist() + growth_signal_df.columns.tolist(
) + derived_df_columns.difference(
['EBITDA', 'Total Debt', 'Free Cash Flow']).tolist()
else:
df = df.dropna(
subset=['Shares (Basic)', 'Shares (Diluted)', 'Revenue'])
non_per_share_cols = [
'Currency', 'Fiscal Year', 'Fiscal Period', 'Published Date',
'Restated Date', 'Shares (Basic)', 'Shares (Diluted)', 'Close',
'Dataset'
] + derived_df_columns.difference(
['EBITDA', 'Total Debt', 'Free Cash Flow']).tolist()
df = df.replace([np.inf, -np.inf], 0)
df = df.fillna(0)
per_share_cols = df.columns[~df.columns.isin(non_per_share_cols)]
df[per_share_cols] = df[per_share_cols].div(df['Shares (Diluted)'], axis=0)
# Add Company and Industry Information and Categorize
df = df.join(company_df).merge(
industry_df, left_on='IndustryId', right_index=True).drop(
columns=['IndustryId', 'Company Name', 'SimFinId'])
categorical_features = [
col for col in df.columns if df[col].dtype == 'object'
]
encoder = OrdinalEncoder(cols=categorical_features,
handle_unknown='ignore',
return_df=True).fit(df)
df = encoder.transform(df)
# Sort
df = df.sort_index(level=['Ticker', 'Date'], ascending=[1, 1])
return df
#prevent error from entering a portfolio with no stocks from reaching user
if len(stock_tickers) == 0:
print(
"Your portfolio is empty. To create an analysis PDF, you must enter at least one stock into your portfolio."
)
else:
#References: Quandl #2/3, Matplotlib #1
#Yahoo Finance Workaround, scrapes data off of Yahoo Finance webpage
earnings_estimates = []
eps_trends = []
growth_estimates = []
negative_growth_stocks = []
positive_growth_stocks = []
for ticker in stock_tickers:
analysts_data = get_analysts_info(ticker)
this_earnings_est = analysts_data['Earnings Estimate'].iloc[1][4]
earnings_estimates.append(this_earnings_est)
this_eps_trend = analysts_data['EPS Trend'].iloc[0][4]
eps_trends.append(this_eps_trend)
this_gest = analysts_data['Growth Estimates'].iloc[0][1]
growth_estimates.append(this_gest)
if '-' in this_gest:
negative_growth_stocks.append(ticker)
else:
positive_growth_stocks.append(ticker)
neg_growth_string = ", ".join(negative_growth_stocks)
pos_growth_string = ", ".join(positive_growth_stocks)
min_value = 0.0
def get_yahoo_fin(prod, outdir):
"""
Query exhaustive information of a stock on Yahoo finance and output to a worksheet
Args:
prod Product object, containing basic info about the stock such as symbol, name, currency etc.
start_date start date string such as '1/1/2018' or '2018-1-1T00:00:00'
end_date end date string such as '30/12/2018' ...
outdir output dir to save the plot
Return:
no return
"""
ticker = prod._symbol
out_path = os.path.join(outdir, f'{prod._name}.xlsx')
print(f'Retrieving data for {prod._name} ...')
writer = pd.ExcelWriter(out_path,engine='xlsxwriter') # Creating Excel Writer Object from Pandas
# summary, quote table, stats
print('\tQuerying summary/quote table/stats ...')
row_count = 0
summ = {'name': prod._name, 'id': prod._id, 'symbol': prod._symbol,
'close price': prod._closeprice,
'close date': prod._closedate,
'current price': si.get_live_price(ticker),
'vwdId': prod._vwdId}
df_summ = dict2dataframe(summ, 'info')
df_summ.rename_axis('Summary', axis='index', inplace=True)
df_summ.to_excel(writer, sheet_name='Summary', startrow=row_count, startcol=0)
row_count = row_count + len(df_summ) + 2
df_quote = dict2dataframe(si.get_quote_table(ticker))
df_quote.rename_axis('Quote table', axis='index', inplace=True)
df_quote.to_excel(writer, sheet_name='Summary', startrow=row_count, startcol=0)
row_count = row_count + len(df_quote) + 2
df_stats = si.get_stats(ticker)
df_stats.rename_axis('Stats', axis='index', inplace=True)
df_stats.to_excel(writer, sheet_name='Summary', startrow=row_count, startcol=0)
row_count = row_count + len(df_stats) + 2
# analyst
print('\tQuerying analyst ...')
ana = si.get_analysts_info(ticker) # this return a dict of pandas dataframes
row_count = 0
for key, df in ana.items():
df.name = key
df.to_excel(writer, sheet_name='Analyst Info', startrow=row_count, startcol=0)
row_count = row_count + len(df) + 2
# balance sheet
print('\tQuerying balance ...')
df_bal = si.get_balance_sheet(ticker)
df_bal.to_excel(writer,sheet_name='Balance', startrow=0 , startcol=0)
# cash flow
print('\tQuerying cash flow ...')
df_cash = si.get_cash_flow(ticker)
df_cash.to_excel(writer,sheet_name='Cash flow', startrow=0 , startcol=0)
# data
print('\tQuerying historic data ...')
df_data = si.get_data(ticker)
df_data.sort_index(ascending=False, inplace=True)
df_data.to_excel(writer,sheet_name='Data', startrow=0 , startcol=0)
# financial
print('\tQuerying financial ...')
fin = si.get_financials(ticker) # this return a dict of dataframes
row_count = 0
for key, df in fin.items():
df.rename_axis(key, axis='index', inplace=True)
df.to_excel(writer, sheet_name='Financial', startrow=row_count, startcol=0)
row_count = row_count + len(df) + 2
# save
writer.save()
print(f'Data saved to {out_path}')
def getAnalystsInfo(self, symbol):
analysis = si.get_analysts_info(symbol)
return {'analysis': self.yahooFinanceDataModification.modifyAnalysis(analysis, symbol)}
def profile(tickers, market, export):
#initialization to prevent null on first iteration
currPrice = 'N/A'
recommendation = 'N/A'
analyst = 'N/A'
earnGrow = 'N/A'
revGrow = 'N/A'
growthEstimateC = 'N/A'
growthEstimateN = 'N/A'
yearTargetPrice = 'N/A'
beta = 'N/A'
industrySec = 'N/A'
for ticker in tickers:
if ("." in ticker and ".V" not in ticker.upper()):
breaker = ticker.find('.', 1)
ticker = ticker[0:breaker] + '-' + ticker[breaker + 1:len(ticker)]
if (market.upper() == "CA"):
ticker = ticker + '.TO'
lhs_url = 'https://query2.finance.yahoo.com/v10/finance/quoteSummary/'
rhs_url = '?formatted=true&crumb=swg7qs5y9UP&lang=en-US®ion=US&' \
'modules=financialData,defaultKeyStatistics,assetProfile,esgScores&' \
'corsDomain=finance.yahoo.com'
url = lhs_url + ticker.upper() + rhs_url
currentCriteria = 'URL ' + url
r = requests.get(url)
if not r.ok:
ticker = ticker.replace('.TO', '.V')
url = f'{lhs_url}{ticker.upper()}{rhs_url}'
r = requests.get(url)
try:
result = r.json()['quoteSummary']['result'][0]
currentCriteria = 'currPrice'
if (len((result['financialData']['currentPrice'])) > 0):
currPrice = "$" + result['financialData']['currentPrice']['fmt']
else:
currPrice = 'N/A'
currentCriteria = 'industry'
if (len((result['assetProfile']['industry'])) > 0
and len(result['assetProfile']['sector']) > 0):
industrySec = result['assetProfile'][
'industry'] + ' in ' + result['assetProfile']['sector']
else:
industrySec = 'N/A'
currentCriteria = 'analyst'
if (len((result['financialData']['numberOfAnalystOpinions'])) > 0):
analyst = result['financialData']['numberOfAnalystOpinions'][
'fmt']
# analyst insights
currentCriteria = 'Current Growth'
ana_insight = si.get_analysts_info(ticker)
if (type(ana_insight['Growth Estimates'].values[2][1]) == str):
growthEstimateC = ana_insight['Growth Estimates'].values[
2][1]
else:
growthEstimateC = 'N/A'
currentCriteria = 'Next Year Growth'
if (type(ana_insight['Growth Estimates'].values[3][1]) == str):
growthEstimateN = ana_insight['Growth Estimates'].values[
3][1]
else:
growthEstimateN = 'N/A'
else:
analyst = 'N/A'
currentCriteria = 'earnGrow'
if (len((result['financialData']['earningsGrowth'])) > 0):
earnGrow = result['financialData']['earningsGrowth']['fmt']
else:
earnGrow = 'N/A'
currentCriteria = 'revGrow'
if (len((result['financialData']['revenueGrowth'])) > 0):
revGrow = result['financialData']['revenueGrowth']['fmt']
else:
revGrow = 'N/A'
currentCriteria = 'recommendation'
if (len((result['financialData']['recommendationMean'])) > 0):
recommendation = result['financialData']['recommendationMean'][
'fmt'] + ' ' + result['financialData'][
'recommendationKey'].upper()
else:
recommendation = 'N/A'
currentCriteria = 'yearlyTargetPrice'
if (len((result['financialData']['targetMeanPrice'])) > 0):
yearTargetPrice = "$" + result['financialData'][
'targetMeanPrice']['fmt']
else:
yearTargetPrice = 'N/A'
currentCriteria = 'beta'
if (len((result['defaultKeyStatistics']['beta'])) > 0):
beta = result['defaultKeyStatistics']['beta']['fmt']
else:
beta = 'N/A'
except:
print(f'errored on : {ticker} for criteria {currentCriteria}')
currentPrice.append(currPrice)
recommendations.append(recommendation)
analystWatching.append(analyst)
earningGrowth.append(earnGrow)
revenueGrowth.append(revGrow)
yearlyTargetPrice.append(yearTargetPrice)
growthEstimates.append(f'{growthEstimateC} : {growthEstimateN}')
betas.append(beta)
industry.append(industrySec)
if (export):
dataframe = pd.DataFrame(
list(
zip(tickers, industry, currentPrice, recommendations,
analystWatching, earningGrowth, revenueGrowth,
yearlyTargetPrice, growthEstimates, betas)),
columns=[
'Company', 'Industry', 'Current Price', 'Recommendations',
'# of observing Analyst', 'Earning Growth %',
'Revenue Growth %', '1y Ago Projected Target Price Est ',
'Growth Estimate (Current:Next Year) ',
'Betas (0 is less volatile)'
])
dataframe = dataframe.set_index('Company')
dataframe.to_csv(f'{market.upper()} - StockDashboard.csv',
encoding='ANSI')
