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: