def update_graph(n_clicks, val, start_date, end_date):
start_date = date.fromisoformat(start_date)
end_date = date.fromisoformat(end_date)
try:
data = web.get_data_tiingo(val,
start=start_date,
end=end_date,
api_key=API_TOKEN)
except:
try:
data = web.get_data_tiingo(val,
start=min_date_allowed,
end=max_date_allowed,
api_key=API_TOKEN)
data = df[(df['startDate'] < min_date_allowed)
& (df['endDate'] > max_date_allowed)]
except:
return html.H2('The API Tiingo is down, restart later.\n See you'
) # full control over the error UI
try:
data = data.reset_index()
data = data.rename(columns={'close': 'price', 'symbol': 'stock'})
fig = px.line(data, x='date', y='price', color='stock')
fig.update_traces(mode="markers+lines")
fig.update_xaxes(showgrid=False, zeroline=True)
return dcc.Graph(id="graph", figure=fig)
except:
return html.Div(
'The NB of API calls to IEX API have been exceeded, retry tomorrow or enter a new API IEX key'
) # full control over the error UI
def get_daily(ticker, api_key, clean=False):
"""Pulls daily data for ticker using api_key strings. Clean resets index."""
# Ex: finance.get_daily('GOOG', 'XXXXXXX.....')
if clean:
df = web.get_data_tiingo(ticker, api_key=api_key)
df = df.reset_index()
return df
else:
return web.get_data_tiingo(ticker, api_key=api_key)
def get_prices(symbols, start, end):
"""
A wrapper function for getting the prices of a
list of ticker symbols
Args:
symbols : list of strings
start : datetime.datetime() of starting day
end : datetime.datetime() of starting day
Returns:
out_df : pd.DataFrame containing dates and prices
"""
if _API_FLAG == "tiingo":
out_df = web.get_data_tiingo(symbols, start, end, api_key=_API_KEY)
out_df = out_df.rename(columns={
"adjClose": "close",
"close": "unAdjClose"
})
elif _API_FLAG == 'rh':
out_df = web.DataReader(symbols, 'robinhood', start, end)
out_df = out_df.rename(columns={'close_price': 'close'})
else:
warnings.warn("No suitable financial data API found during import.")
return out_df
def update_graph(n_clicks, stock_ticker, start_date, end_date):
start = datetime.strptime(start_date[:10], '%Y-%m-%d')
end = datetime.strptime(end_date[:10], '%Y-%m-%d')
traces = []
for tic in stock_ticker:
df = web.get_data_tiingo(
tic,
start,
end,
api_key="45a001c507ffe97a1f8781ba47249357fc9551bf")
df = df.assign(changes=df['close'].diff() / 100)
# print(df)
# print(df.columns)
df.index = df.index.get_level_values('date')
traces.append({'x': df.index, 'y': df['changes'], 'name': tic})
fig2 = {
'data':
traces,
'layout':
go.Layout(title=', '.join(stock_ticker) + ' Daily Changes',
yaxis={'title': 'Daily changes in %'},
xaxis={'showticklabels': False})
}
return fig2
def retrieve_latest_security_price():
now = datetime.datetime.now()
yesterday = now - datetime.timedelta(3)
start = datetime.datetime(yesterday.year, yesterday.month, yesterday.day)
end = datetime.datetime(now.year, now.month, now.day)
bad_tickers = []
print('...retrieving current market price data...')
for i, t in enumerate(tickers):
try:
if i==0:
ohlc = pdr.get_data_tiingo(t, api_key=tiingo_key).tail(1).close
else:
ohlc = ohlc.append(pdr.get_data_tiingo(t, api_key=tiingo_key).tail(1).close)
except:
bad_tickers.append(t)
print(bad_tickers)
return ohlc
def update_graph(n_clicks, stock_ticker, start_date, end_date):
start = datetime.strptime(start_date[:10], '%Y-%m-%d')
end = datetime.strptime(end_date[:10], '%Y-%m-%d')
df = web.get_data_tiingo(stock_ticker,start,end, api_key="efcb8226f45a832dae79835ef5d42dd427a53cfb")
fig = {
'data': [
{'x': df.index.get_level_values(1), 'y': df['close']}
],
'layout': {'title':stock_ticker}
}
return fig
def update_graph(n_clicks, stock_ticker, start_date, end_date):
start = datetime.strptime(start_date[:10], '%Y-%m-%d')
end = datetime.strptime(end_date[:10], '%Y-%m-%d')
traces = []
for tic in stock_ticker:
df = web.get_data_tiingo(tic, start, end, api_key="efcb8226f45a832dae79835ef5d42dd427a53cfb")
traces.append({'x':df.index.get_level_values(1), 'y': df['close'], 'name':tic})
return {
'data': traces,
'layout': {'title':', '.join(stock_ticker)+' Closing Prices'}
}
def _get_historical_prices(self, tickers, start_date, end_date):
try:
api_key = os.getenv('TIINGO_API_KEY')
except KeyError:
print("Missing TIINGO_API_KEY")
# Get data from TIINGO
pf = web.get_data_tiingo(symbols=tickers,
api_key=api_key,
start=start_date,
end=end_date)
pf = pf.to_panel()
pf = pf.swapaxes(1, 2)
return pf
def get_save_index(self, scale=True):
if os.path.isfile("/home/ian/index_data.npy"):
index = np.load("/home/ian/index_data.npy")
else:
index = pdata.get_data_tiingo(symbols="DIA", start=self.start, end=self.endDate,
api_key=self._apiKey).as_matrix()[:, :5]
np.save("/home/ian/index_data", index)
if scale:
scaler = MinMaxScaler()
index = scaler.fit_transform(index)
index_array = np.zeros(shape=[len(index) - 20, 20, 5])
recent_array = index[-20:]
for i in range(20, len(index)):
index_array[i - 20] = index[i - 20:i]
return index_array, recent_array
def update_graph(n_clicks, stock_ticker, start_date, end_date):
start = datetime.strptime(start_date[:10], '%Y-%m-%d')
end = datetime.strptime(end_date[:10], '%Y-%m-%d')
df = web.get_data_tiingo(stock_ticker, start, end, api_key=TIINGO_API_KEY)
df.index = df.index.get_level_values('date')
fig = {
'data': [{
'x': df.index,
'y': df['adjClose']
}],
'layout': {
'title': stock_ticker
}
}
return fig
def update_graph(stock_ticker):
start = datetime(2017, 1, 1)
end = datetime(2020, 10, 10)
df = web.get_data_tiingo(stock_ticker, start, end, api_key=TIINGO_API_KEY)
df.index = df.index.get_level_values('date')
fig = {
'data': [{
'x': df.index,
'y': df['adjClose']
}],
'layout': {
'title': stock_ticker
}
}
return fig
def update_graph(n_clicks, stock_ticker, start_date, end_date):
start = datetime.strptime(start_date[:10], '%Y-%m-%d')
end = datetime.strptime(end_date[:10], '%Y-%m-%d')
# stock_ticker is now a list of symbols
# We must create a list of traces for our figure
traces = []
# use string formatting to include all symbols in the chart title
title = ', '.join(stock_ticker) + ' Closing Prices'
for tic in stock_ticker:
try:
df = web.get_data_tiingo(tic, start, end, api_key=TIINGO_API_KEY)
# testing our exception works
# df = web.get_data_tiingo(tic, start, end, api_key='NOPE')
df.index = df.index.get_level_values('date')
# testing our data
# df.to_csv('tiingo.csv')
# traces.append({'x':df.index, 'y': df.close, 'name':tic})
# adjClose appears to be more accurate
traces.append({'x': df.index, 'y': df.adjClose, 'name': tic})
except:
try:
# Because stock APIs change all the time this is a backup where
# we are downloading the data from yahoo instead of using an API
start = pd.to_datetime([
start
]).astype(int)[0] // 10**9 # convert to unix timestamp.
end = pd.to_datetime([
end
]).astype(int)[0] // 10**9 # convert to unix timestamp.
url = 'https://query1.finance.yahoo.com/v7/finance/download/' + tic + '?period1=' + str(
start) + '&period2=' + str(
end) + '&interval=1d&events=history'
df = pd.read_csv(url)
# testing our data
# df.to_csv('yahoo.csv')
traces.append({'x': df.Date, 'y': df.Close, 'name': tic})
except:
# Throw a warning if both API and workaround stop working
title = "OH NO!! Unfortunately some APIs change over time!! Tweet @yesthisiskendra to let her know!!"
fig = {
# set data equal to traces
'data': traces,
'layout': {
'title': title
}
}
return fig
def update_graph(stock_ticker):
start = datetime(2017, 1, 1)
end = datetime(2017, 12, 31)
df = web.get_data_tiingo(
stock_ticker,
start,
end,
api_key="efcb8226f45a832dae79835ef5d42dd427a53cfb")
fig = {
'data': [{
'x': df.index.get_level_values(1),
'y': df.close
}],
'layout': {
'title': stock_ticker
}
}
return fig
def get_daily_historic_data_tiingo(ticker):
"""Obtains full historical data from Tiingo returns a list of tuples.
ticker: Ticker symbol, e.g. "GOOG" for Google, Inc."""
# Construct the URL with the correct integer query parameters
# av_json = urllib2.urlopen("https://www.alphavantage.co/query?function=TIME_SERIES_DAILY&symbol=%s&outputsize=full&apikey=YD2DLTZBJFNPFVX2" % (ticker))
# Try connecting to IEX and obtain the data
# On failure, print an error message.
try:
tiingo_data = web.get_data_tiingo(ticker,
api_key=dbconf.tiingo_API_key)
tiingo_data = tiingo_data.reset_index('symbol')
prices = []
for row in tiingo_data.itertuples():
prices.append((row.Index.strftime('%Y-%m-%d'), row.open, row.high,
row.low, row.close, row.volume))
except Exception, e:
print("Could not download Tiingo data: %s" % e)
def update_graph(n_clicks, stock_picker, start_date, end_date):
start_date = datetime.strptime(start_date[:10], "%Y-%m-%d")
end_date = datetime.strptime(end_date[:10], "%Y-%m-%d")
traces = []
for tick in stock_picker:
df = web.get_data_tiingo(symbols=tick, start=start_date, end=end_date)
df[['symbol', 'date']] = pd.DataFrame(df.index.tolist(),
index=df.index)
traces.append({'x': df.date, 'y': df.close, 'name': tick})
fig = dict(
data=traces,
layout={
'title':
"Stock Prices between " + str(start_date.strftime('%b %d %Y')) +
" and " + str(end_date.strftime('%b %d %Y'))
})
return fig
def update_graph(n_clicks, stock_value, start, end):
traces = []
for i in stock_value:
stock = web.get_data_tiingo(stock_value,
api_key=os.getenv('TIINGO_API_KEY'),
start=start,
end=end)
traces.append({
'x': stock.loc[i].index,
'y': stock.loc[i]["close"],
'name': i
})
figure = {
'data': traces,
'layout': {
'title': ', '.join(stock_value) + ' Closing Prices',
'plot_bgcolor': 'rgba(255,255,255,1)'
}
}
return figure
def update_candle_graph(n_clicks, stock_value, start, end):
data = []
for i in stock_value:
stock = web.get_data_tiingo(stock_value,
api_key=os.getenv('TIINGO_API_KEY'),
start=start,
end=end)
data.append(
go.Candlestick(x=stock.loc[i].index,
open=stock.loc[i]["open"],
high=stock.loc[i]["high"],
low=stock.loc[i]["low"],
close=stock.loc[i]["close"],
name=i))
figure = go.Figure(data=data,
layout=go.Layout(plot_bgcolor='rgba(255,255,255,1)',
xaxis=dict(gridcolor="#eee"),
yaxis=dict(gridcolor="#eee")))
return figure
def __init__(self, **kwargs):
self.logger = get_logger()
self.file_mod_time_dict = {}
self.symbols = None
self.start_date = ""
self.end_date = ""
self.source = "tiingo"
self.api_key = SecureKeysAccess.get_vendor_api_key_static(
vendor=str.upper(self.source))
for key, value in kwargs.items():
if key == 'symbols':
self.symbols = value
self.logger.info("TiingoDataObject.__init__.symbols: %s",
str(self.symbols))
elif key == 'start_date':
self.start_date = value
self.logger.info("TiingoDataObject.__init__.start_date: %s",
str(self.start_date))
elif key == 'end_date':
self.end_date = value
self.logger.info("TiingoDataObject.__init__.end_date: %s",
str(self.end_date))
elif key == 'source':
self.source = value
self.logger.info("TiingoDataObject.__init__.source: %s",
str(self.source))
self.get_px_all_tiingo = lambda x: web.get_data_tiingo(
x,
start='2010-01-01',
end=str(pd.to_datetime('today')).split(' ')[0],
api_key=self.api_key)
self.all_px_df = None
self.local_tiingo_data_path = '/workspace/data/tiingo/stocks/'
self.local_file_type = '.csv'
self.local_data_file_pwd = OSMuxImpl.get_proper_path(
self.local_tiingo_data_path)
def download_save_market_data(api_key, symbols, start_date, end_date):
"""
Return market data
Keyword arguments:
api_key: API for market data source
symbols: list of symbols, index will be appended
start_date: pd.Timestamp
end_date: pd.Timestamp
"""
# Downloading prices for all symbols and SPY for market baseline
# will append if SPY is in symbols list to have index in last column
symbols = list(symbols)
symbols.append("SPY")
market = web.get_data_tiingo(api_key=api_key,
symbols=symbols,
start=start_date,
end=end_date)
market.to_pickle("data/market.pkl")
return market
def update_graph(n_clicks, stock_ticker, start_date, end_date):
start = datetime.strptime(start_date[:10], '%Y-%m-%d')
end = datetime.strptime(end_date[:10], '%Y-%m-%d')
traces = []
for tic in stock_ticker:
df = web.get_data_tiingo(
tic,
start,
end,
api_key="45a001c507ffe97a1f8781ba47249357fc9551bf")
df.index = df.index.get_level_values('date')
traces.append({'x': df.index, 'y': df['close'], 'name': tic})
fig1 = {
'data':
traces,
'layout':
go.Layout(title=', '.join(stock_ticker) + ' Closing Prices',
yaxis={'title': 'Stock Prices in USD'})
}
return fig1
def __init__(self, symbol, years, use_index=True, categorize=True, scale=False, num_cats=5):
self.endDate = datetime.now().date() - timedelta(days=1)
self.start = datetime(self.endDate.year - int(years), self.endDate.month, self.endDate.day) - timedelta(days=1)
self._apiKey = "af08d3cdca987b9b5f0101ca0a63984ce6ab03d0"
self.stockData = pdata.get_data_tiingo(symbols=symbol.upper(), start=self.start, end=self.endDate,
api_key=self._apiKey).as_matrix()[:, :5]
self.stockData_out = np.asarray([x for x in self.stockData])
print(self.endDate)
datapoints = len(self.stockData)
print(str(datapoints) + " records received for: " + symbol)
if scale:
scaler = MinMaxScaler()
self.stockData = scaler.fit_transform(self.stockData)
self.inputs = np.zeros(shape=[datapoints - 20, 20, 5])
self.outputs = np.zeros(shape=datapoints - 20)
self._build_raw()
self.outputs_freeze = self.outputs
if categorize:
self.outputs = self.categorize_outputs(num_cats)
if use_index:
self.index_data = self.get_save_index()
self.inputs = self._append_index(self.inputs, self.index_data[0])
# beginning date from which program calls daily stock data
startDate = '9/9/2014'
# number of iterations for Monte Carlo simulation
iterations = 10000
# risk free rate assumption
rf = .02
callDict = {} # dictionary of price data called direct from Morningstar
titleDict = {} # dictionary of titles to be applied to the raw value dataframe
aggregateDict = {} # dictionary of 1-column DF's of price data for each stock
results = {} # array for Monte Carlo results
dailyChange = {} # daily change data
# call daily close price data for each stock
for i in range(len(tickers)):
callDict[tickers[i]] = web.get_data_tiingo(tickers[i], start=startDate, api_key=tingoApiKey).iloc[:, 5]
# format each callDict to single dictionary
for j in range(len(tickers)):
titleDict["title" + str(j)] = [tickers[j]]
aggregateDict[tickers[j]] = pd.DataFrame(callDict[tickers[j]].values, columns = list(titleDict["title"+str(j)]))
if j == 0:
df = aggregateDict[tickers[j]]
else:
df = pd.concat([df, aggregateDict[tickers[j]]], axis = 1)
# create dataframe showing percent change, construct covariance matrix, prepare results array for Monte Carlo simulation
dailyChange = pd.DataFrame(data = df.pct_change().iloc[1:,:])
cov_matrix = dailyChange.cov()
results = np.zeros((3+len(tickers),iterations))
max_date_allowed = datetime.now() - timedelta(days=2)
df = tiingo.get_tiingo_symbols()
df = df.dropna()
df['startDate'] = pd.to_datetime(df['startDate'])
df['endDate'] = pd.to_datetime(df['endDate'])
#symb =symb['ticker'].iloc[4309:].values
df = df[(df['startDate'] < min_date_allowed)
& (df['endDate'] > max_date_allowed)]
symb = df['ticker'].values
API_TOKEN = 'd65139f94845e295c10bdcb614021a21c17f2326'
start_dt = min_date_allowed.date()
end_dt = max_date_allowed.date()
data = web.get_data_tiingo(['AA', 'AAAAX'],
start=start_dt,
end=end_dt,
api_key=API_TOKEN)
data = data.reset_index()
data = data.rename(columns={'close': 'price', 'symbol': 'stock'})
fig = px.line(data, x='date', y='price', color='stock')
fig.update_traces(mode="markers+lines")
fig.update_xaxes(showgrid=False, zeroline=True)
layout = html.Div([
html.H1("Stock Price App using Tingo API"),
html.Hr(),
html.Div([
dbc.Row([
dbc.Col(children=dcc.Dropdown(id='StockType',
options=[{
'label': i,
def update_table(n_clicks, stock_value, start, end):
tables = []
if len(stock_value) < 2:
table_size = 12
else:
table_size = 6
for i in stock_value:
stock = web.get_data_tiingo(stock_value,
api_key=os.getenv('TIINGO_API_KEY'),
start=start,
end=end)
table_data = stock.reset_index()[stock.reset_index()["symbol"] == i]
table_data["date"] = table_data["date"].dt.strftime('%d.%m.%Y ')
tables.append(
dfx.Col(xs=12,
lg=table_size,
children=[
dash_table.DataTable(
id='table',
columns=[{
"name": i,
"id": i,
"deletable": True,
"selectable": True
} for i in table_data.columns],
data=table_data.to_dict("records"),
fixed_rows={
'headers': True,
'data': 0
},
style_table={
'maxHeight': '300px',
'overflowY': 'scroll',
'overflowX': 'scroll',
'border': 'thin lightgrey solid'
},
style_cell={
'minWidth': '100px',
'width': '100px',
'maxWidth': '100px',
'overflow': 'hidden',
'textOverflow': 'ellipsis',
},
editable=True,
filter_action="native",
sort_action="native",
sort_mode="multi",
column_selectable="single",
row_selectable="multi",
row_deletable=True,
selected_columns=[],
selected_rows=[],
page_action="native",
page_current=0,
page_size=10)
]))
return tables
def update_stock_data(self, company_code):
df = pdr.get_data_tiingo(company_code, api_key=self.pandas_key)
df.to_csv(data_path + company_code + stock_ext)
from pandas_datareader import data, wb
import pandas as pd
import numpy as np
import datetime
import matplotlib.pyplot as plt
import seaborn as sns
import os
import chart_studio.plotly as iplot
import cufflinks as cf
start = datetime.datetime(2006, 1, 1)
end = datetime.datetime(2016, 1, 1)
BAC_data = data.get_data_tiingo(
'BAC',
api_key='66d0fd8f718e53b4dd3b76fce1d34c53ee8d7dc1',
start=start,
end=end)
C_data = data.get_data_tiingo(
'C',
api_key='66d0fd8f718e53b4dd3b76fce1d34c53ee8d7dc1',
start=start,
end=end)
GS_data = data.get_data_tiingo(
'GS',
api_key='66d0fd8f718e53b4dd3b76fce1d34c53ee8d7dc1',
start=start,
end=end)
MS_data = data.get_data_tiingo(
'MS',
api_key='66d0fd8f718e53b4dd3b76fce1d34c53ee8d7dc1',
#This is my share price visualisation of the FAANG stocks.
#@author Marius Haueis
#@version 14.04.2021
from matplotlib import pyplot as plt
import pandas_datareader.data as web
api_key = None #insert your Tiingo api key here.
time = [2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021]
money = [0, 500, 1000, 1500, 2000, 2500, 3000, 3500, 4000]
#Data import and storage into variables.
facebook = web.get_data_tiingo("FB", api_key=api_key)
google = web.get_data_tiingo("GOOGL", api_key=api_key)
amazon = web.get_data_tiingo("AMZN", api_key=api_key)
aaple = web.get_data_tiingo("AAPL", api_key=api_key)
netflix = web.get_data_tiingo("NFLX", api_key=api_key)
#Creating the curves.
plt.plot(range(len(facebook)), facebook["close"])
plt.plot(range(len(google)), google["close"])
plt.plot(range(len(amazon)), amazon["close"])
plt.plot(range(len(aaple)), aaple["close"])
plt.plot(range(len(netflix)), netflix["close"])
plt.legend(["Facebook", "Alphabet", "Amazon", "Apple", "Netflix"], loc=2)
plt.title("FAANG Share price comparison")
plt.xlabel("Time in years")
plt.ylabel("Prince in Dollar")
ax = plt.subplot()
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from pandas_datareader import data, wb
from datetime import datetime
#import os
start = datetime(year=2012, month=1, day=1)
end = datetime(year=2017, month=1, day=1)
TSLA_data = data.get_data_tiingo(
'TSLA',
api_key='f4604e85f25e80abde0747cbdeeecbb7cb5ee3ec',
start=start,
end=end)
Ford_data = data.get_data_tiingo(
'F',
api_key='f4604e85f25e80abde0747cbdeeecbb7cb5ee3ec',
start=start,
end=end)
GM_data = data.get_data_tiingo(
'GM',
api_key='f4604e85f25e80abde0747cbdeeecbb7cb5ee3ec',
start=start,
end=end)
#print(TSLA_data)
#print(Ford_data)
#print(GM_data)
app = dash.Dash(
__name__,
meta_tags=[{
"name": "viewport",
"content": "width=device-width, initial-scale=1"
}],
)
#auth = dash_auth.BasicAuth(app, USERNAME_PASSWORD_PAIRS)
server = app.server
nsdq = pd.read_csv('data/NASDAQcompanylist.csv')
nsdq.set_index('Symbol', inplace=True)
stock = web.get_data_tiingo('GOOG', api_key=os.getenv('TIINGO_API_KEY'))
table_test = pd.read_csv(
'https://raw.githubusercontent.com/plotly/datasets/master/solar.csv')
layout = dict(
autosize=True,
automargin=True,
margin=dict(l=30, r=30, b=20, t=40),
hovermode="closest",
legend=dict(font=dict(size=10), orientation="h"),
title="Stock Ticker",
className='layout',
fluid=True,
)
#This is a visualization of the expected returns and volatilitys of several choosen shares.
#@author Marius Haueis
#@version 16.04.2021
import pandas_datareader.data as web
from matplotlib import pyplot as plt
import numpy as np
#import of data
api_key = None #insert your Tiingo api key here.
intel = web.get_data_tiingo("INTC", api_key=api_key)
adobe = web.get_data_tiingo("ADBE", api_key=api_key)
morgan_stanley = web.get_data_tiingo("MS", api_key=api_key)
boeing = web.get_data_tiingo("BCO", api_key=api_key)
ea = web.get_data_tiingo("EA", api_key=api_key)
exxon = web.get_data_tiingo("XOM", api_key=api_key)
home_depot = web.get_data_tiingo("HD", api_key=api_key)
stocks = [intel, adobe, morgan_stanley, boeing, ea, exxon, home_depot]
stocks_name = [
"Intel", "Adobe", "Morgan Stanley", "Boeing", "EA", "Exxon", "Home Depot"
]
#returns and risk calculation
def stage(df):
closing_price = df["close"].pct_change()
ic = closing_price[1:]
avg_ret = ic.mean()
variance = 0.00
for i in ic:
