def download_json_data(companies, mode):
ts = TimeSeries(key='8T5R3MKIOEJGAL8F', output_format='json', retries=10)
data, meta_data = {}, {}
for company in companies:
if mode == 'daily':
data[company], meta_data[company] = ts.get_daily_adjusted(
symbol=company, outputsize='full')
elif mode == 'monthly':
data[company], meta_data[company] = ts.get_monthly_adjusted(
symbol=company)
elif mode == 'intraday':
data[company], meta_data[company] = ts.get_intraday(
symbol=company, interval='1min', outputsize='full')
elif mode == 'batch':
data[company], meta_data[company] = ts.get_batch_stock_quotes(
companies)
return data
else:
print(
"Only supported modes are 'daily','monthly', 'intraday', 'batch'"
)
return data
print("Finished: " + company)
time.sleep(12)
return data
def Time_series(name, time, output, type):
#ts = TimeSeries(key=API_key, output_format='pandas')
ts = TimeSeries(key=API_key)
if (type == 'Intraday'):
data, meta_data = ts.get_intraday(symbol=name,
interval=time,
outputsize=output)
#print_time_series(data,name,time,type)
return data
elif (type == 'Day Adjusted'):
data, meta_data = ts.get_daily_adjusted(symbol=name, outputsize=output)
print_time_series(data, name, time, type)
elif (type == 'Weekly'):
data, meta_data = ts.get_weekly(symbol=name)
print_time_series(data, name, time, type)
elif (type == 'Weekly Adjusted'):
data, meta_data = ts.get_weekly_adjusted(symbol=name)
print_time_series(data, name, time, type)
elif (type == 'Monthly'):
data, meta_data = ts.get_monthly(symbol=name)
#print_time_series(data,name,time,type)
description(data, name, time, type)
elif (type == 'Monthly Adjusted'):
data, meta_data = ts.get_monthly_adjusted(symbol=name)
print_time_series(data, name, time, type)
def __init__(self, ticker):
super().__init__()
# TODO: don't hardcode this
self.rF = .001
# alpha vantage
key = input('API key: ')
ts = TimeSeries(key, output_format='pandas')
# pull spot prices
tick_data, _ = ts.get_monthly_adjusted(symbol=ticker)
tick_data = tick_data.sort_index()
self.S = tick_data.loc[tick_data.index[-3:-1], '5. adjusted close']
# up/down returns
rS_up = .1
rS_dn = -.1
# TODO: think about other ways to select Su, Sd, K
self.Su = (1. + rS_up) * self.S[0]
self.Sd = (1. + rS_dn) * self.S[0]
# basic info
self.tick = ticker
self.date = tick_data.index[-2].isoformat()[:10],
def pull_data(ticker, pullType, interval='0', key='1RJDU8R6RESLVE09'):
ts = TimeSeries(key=key, output_format='pandas')
if pullType == 'intraday':
data1, meta_data1 = ts.get_intraday(symbol=ticker,
interval=interval,
outputsize='full')
data1.columns = ['Open', 'High', 'Low', 'Close', 'Volume']
print('Pulled intraday with interval = ' + interval + '\n')
elif pullType == 'daily':
data1, meta_data1 = ts.get_daily_adjusted(symbol=ticker,
outputsize='full')
data1 = data1.iloc[:, [0, 1, 2, 3, 5, 6, 7]]
data1.columns = [
'Open', 'High', 'Low', 'Close', 'Volume', 'Dividend', 'Split Coef'
]
print('Pulled daily\n')
elif pullType == 'weekly':
data1, meta_data1 = ts.get_weekly_adjusted(symbol=ticker)
data1 = data1.iloc[:, [0, 1, 2, 3, 5, 6]]
data1.columns = ['Open', 'High', 'Low', 'Close', 'Volume', 'Dividend']
print('Pulled weekly\n')
elif pullType == 'monthly':
data1, meta_data1 = ts.get_monthly_adjusted(symbol=ticker)
data1 = data1.iloc[:, [0, 1, 2, 3, 5, 6]]
data1.columns = ['Open', 'High', 'Low', 'Close', 'Volume', 'Dividend']
print('Pulled monthly\n')
else:
print('Please enter a valid pull type')
data1['DT'] = data1.index
return data1
def get_monthly_closing(ticker):
# Credentials
key = "KE59ELWQ1XLDO5ZR"
ts = TimeSeries(key, output_format="pandas", indexing_type="integer")
# Query by ticker
data, meta_data = ts.get_monthly_adjusted(symbol=ticker.upper())
# Only keep relevant columns
prices = data[["index", "4. close", "5. adjusted close"]]
# Rename columns
prices.rename(
columns={
"index": "date",
"4. close": "monthly_close",
"5. adjusted close": "monthly_close_adjusted",
},
inplace=True,
)
# Convert dates from strings to datetime objects
prices["date"] = prices["date"].apply(lambda x: parse(str(x)))
# Return ticker and stock data
return ticker, prices
def processData(ticker):
ts = TimeSeries('DRLVZJXZ2S4ULOCH', output_format='pandas')
Monthly_TS_df, meta_data = ts.get_monthly_adjusted(symbol=ticker)
#Change column names to approprate form,
for column in Monthly_TS_df.columns:
Monthly_TS_df.rename({column: column.split('. ')[1]},
axis=1,
inplace=True)
return Monthly_TS_df.sort_values('date')
def pull_data(ticker, pullType, interval='0', key='1RJDU8R6RESLVE09'):
ts = TimeSeries(key=key, output_format='pandas')
if pullType == 'intraday':
data1, meta_data1 = ts.get_intraday(symbol=ticker,
interval=interval,
outputsize='full')
data1.columns = ['Open', 'High', 'Low', 'Close', 'Volume']
if interval == '1min':
td = 1
elif interval == '5min':
td = 5
elif interval == '15min':
td = 15
elif interval == '30min':
td = 30
elif interval == '60min':
td = 60
else:
td = 0
data1['TimeDelta'] = td * 60 * 1000 * .75
print('Pulled intraday with interval = ' + interval + '\n')
elif pullType == 'daily':
data1, meta_data1 = ts.get_daily_adjusted(symbol=ticker,
outputsize='full')
data1 = data1.iloc[:, [0, 1, 2, 3, 5, 6, 7]]
data1.columns = [
'Open', 'High', 'Low', 'Close', 'Volume', 'Dividend', 'Split Coef'
]
data1['TimeDelta'] = 24 * 60 * 60 * 1000 * .75
print('Pulled daily\n')
elif pullType == 'weekly':
data1, meta_data1 = ts.get_weekly_adjusted(symbol=ticker)
data1 = data1.iloc[:, [0, 1, 2, 3, 5, 6]]
data1.columns = ['Open', 'High', 'Low', 'Close', 'Volume', 'Dividend']
data1['TimeDelta'] = 7 * 24 * 60 * 60 * 1000 * .75
print('Pulled weekly\n')
elif pullType == 'monthly':
data1, meta_data1 = ts.get_monthly_adjusted(symbol=ticker)
data1 = data1.iloc[:, [0, 1, 2, 3, 5, 6]]
data1.columns = ['Open', 'High', 'Low', 'Close', 'Volume', 'Dividend']
data1['TimeDelta'] = 30 * 24 * 60 * 60 * 1000 * .75
print('Pulled monthly\n')
else:
print('Please enter a valid pull type')
print('Data collected in dataframe data1\n')
data1['DT'] = data1.index
print(type(data1.DT[0]))
#data1['DT'] = pd.to_datetime(data1.index)
#data1['DT'] = data1.DT.strftime('%Y/%d/%m/%H/%M')
return data1
def pull_tick_monthly(self, tick, adjusted=True):
self.tracker.wait()
ts = TimeSeries(key=self.key, output_format='pandas')
if adjusted:
df, meta_data = ts.get_monthly_adjusted(tick)
else:
df, meta_data = ts.get_monthly(tick)
df = df.reset_index()
df['ticker'] = tick
self.tracker.update(1)
return df
def output(self):
"""
Retrieve stock data
@return TableWrapper of stock data
"""
stock_symbols = self.ap_paramList[0]()
timeseries_retriever = TimeSeries(key=DataFetcher.getConfigItem(
'stocks', 'api_key'),
output_format='pandas',
indexing_type='date')
data_dict = OrderedDict()
metadata_dict = OrderedDict()
for symbol in stock_symbols:
# Extract data
if self.data_type == 'daily':
data, metadata = timeseries_retriever.get_daily(
symbol, outputsize='full')
elif self.data_type == 'daily_adjusted':
data, metadata = timeseries_retriever.get_daily_adjusted(
symbol, outputsize='full')
elif self.data_type == 'monthly':
data, metadata = timeseries_retriever.get_monthly(symbol)
elif self.data_type == 'monthly_adjusted':
data, metadata = timeseries_retriever.get_monthly_adjusted(
symbol)
elif self.data_type == 'weekly':
data, metadata = timeseries_retriever.get_weekly(symbol)
elif self.data_type == 'weekly_adjusted':
data, metadata = timeseries_retriever.get_weekly_adjusted(
symbol)
elif self.data_type == 'intraday':
data, metadata = timeseries_retriever.get_weekly_adjusted(
symbol, self.interval, outputsize='full')
# Convert index to pandas datetime
if self.data_type == 'intraday':
data.index = pd.to_datetime(data.index).tz_localize(
metadata['6. Time Zone'])
else:
data.index = pd.to_datetime(data.index)
data_dict[symbol] = data[self.start_date:self.end_date]
metadata_dict[symbol] = metadata
return TableWrapper(data_dict, meta_data=metadata_dict)
def get_monthly(key, symbol):
ts = TimeSeries(key)
ts_data, meta = ts.get_monthly_adjusted(symbol)
dates = []
print("")
for i in meta:
print(i, meta[i])
print("")
for date in ts_data:
dates.append(date)
for i in dates:
print("-------------------------------------\n", i, "\n-------------------------------------\n")
for j in ts_data[i]:
print("{} : {}".format(j, ts_data[i][j], 3))
print("")
def get_dividends(key, symbol):
ts = TimeSeries(key)
ts_data, meta = ts.get_monthly_adjusted(symbol)
dividend_dates = []
print("")
for i in meta:
print(i[3::] + ": ", meta[i])
print("")
for date in ts_data:
dividend_dates.append(date)
for i in dividend_dates:
print(i, " ", end="")
for j in ts_data[i]:
if j == "7. dividend amount":
print("{}: {}".format(j[3::].capitalize(), ts_data[i][j], 3))
print("")
def getPriceHistory():
sym = request.args.get("sym", default=None, type=str)
ts = TimeSeries(key='redacted')
# Get json object with the intraday data and another with the call's metadata
try:
data, meta_data = ts.get_monthly_adjusted(sym)
except Exception as ex:
res = current_app.make_response("Could not fetch price data")
print(traceback.format_exc())
res.status_code = 404
return res
prices = {}
for k in data.keys():
#pick closing price for each day
price = data[k]["4. close"]
#ignore gaps
if (float(price) != 0):
prices[k] = data[k]["4. close"]
#todo store prices in new db table?
return json.dumps(prices)
class data_pulling:
def __init__(self):
self.api_key = 'MNTZV7K3L1FTVL7C'
self.ts = TimeSeries(key=self.api_key, output_format='Pandas')
now = datetime.now()
yest_day = now + timedelta(days=-1)
yest_day = yest_day.strftime('%Y-%m-%d')
self.date1 = yest_day
def calculation(self):
for name in [
'AAPL', 'ABT', 'AMD', 'FB', 'IBM', 'INFY', 'KODK', 'MSFT',
'SBUX', 'TSLA', 'TTM', 'TWTR'
]:
if name == 'IBM' or name == "SBUX":
time.sleep(60)
data, metadata = self.ts.get_monthly_adjusted(symbol=name)
data.rename(columns={
'5. adjusted close': 'adjusted_close',
'1. open': 'open',
'2. high': 'high',
'3. low': 'low',
'4. close': 'close',
'6. volume': 'volume'
},
inplace=True,
errors="raise")
data['date'] = data.index
data = data[data['date'] >= self.date1]
data['date'] = pd.to_datetime(data['date'])
df1 = pd.read_excel(
f"D:\\python_files\\stock\\datasets\\{name}.xlsx")
df1.sort_values(by=['date'], ascending=[True], inplace=True)
df1 = df1.append(data)
df1.sort_values(by=['date'], ascending=[True], inplace=True)
df1['date'] = df1['date'].dt.date
df1.to_excel(f"D:\\python_files\\stock\\datasets\\{name}.xlsx",
index=False)
print(df1)
def get_ticker_df_alpha_vantage(ticker, mode='day'):
API_KEY = str(keyring.get_password('av', 'u1'))
# print type(API_KEY)
ts = TimeSeries(key=API_KEY)
if mode == 'month':
data, meta_data = ts.get_monthly_adjusted(ticker)
elif mode == 'day':
data, meta_data = ts.get_daily_adjusted(ticker)
elif mode == 'intraday':
data, meta_data = ts.get_intraday(ticker)
df = pd.DataFrame(data)
# pdb.set_trace()
df['name'] = df.index
df['name'] = df['name'].apply(lambda x: x.split('.')[1].strip())
df.index = df['name']
df.pop('name')
df = df.stack()
df = pd.to_numeric(df)
df = df.unstack(0)
# print ndf.cov()
# print ndf.describe()
# print ndf
return df
class DataCenter:
def __init__(self, symbol):
self.symbol = symbol
self.iex_base_url = "https://api.iextrading.com/1.0/"
self.ts = TimeSeries(key=API_KEY, retries=100, output_format='pandas')
def get_intraday(self, interval='15min', outputsize='compact'):
df, meta_data = self.ts.get_intraday(symbol=self.symbol,
interval=interval,
outputsize=outputsize)
df.columns = ['Open', 'High', 'Low', 'Close', 'Volume']
df['Date'] = pd.to_datetime(df.index.values)
return df
def get_daily(self, outputsize='compact'):
df, meta_data = self.ts.get_daily_adjusted(symbol=self.symbol,
outputsize=outputsize)
return alter_data(df)
def get_weekly(self):
df, meta_data = self.ts.get_weekly_adjusted(symbol=self.symbol)
return alter_data(df)
def get_monthly(self):
df, meta_data = self.ts.get_monthly_adjusted(symbol=self.symbol)
return alter_data(df)
def get_company(self):
try:
r = requests.get("{}stock/{}/company".format(
self.iex_base_url, self.symbol))
data = r.json()
data = pd.DataFrame.from_dict(data, orient='columns').head(1)
return data
except Exception as err:
return None
from alpha_vantage.timeseries import TimeSeries
key = 'M4JP31006H3PKZ8T'
outputsize = 'compact'
symbol = input('Ticker : ')
typ = input('Data type- "daily", "weekly", "monthly", "interval" : ')
ts = TimeSeries(key, output_format='pandas')
if typ == 'daily':
state = ts.get_daily_adjusted(symbol, outputsize=outputsize)[0]
elif typ == 'weekly':
state = ts.get_weekly_adjusted(symbol)[0]
elif typ == 'monthly':
state = ts.get_monthly_adjusted(symbol)[0]
elif typ == 'interval':
interval = input('Interval-1min, 5min, 15min, 30min, 60min : ')
state = ts.get_intraday(symbol, interval=interval,
outputsize=outputsize)[0]
else:
print('Wrong input given by the user')
print(state)
def __init__(self, key, tickers, rF=0., h=5, to_csv=True):
"""
Initializes Portfolio object
Parameters
----------
x : array like object
Weights
tickers : list
A list of tickers
dow : boolean
If True, loads tickers from the DIJA
rF : float
Risk-free rate
hor : int
Horizon
Examples
--------
"""
# rates
self.rF = rF
# load tickers and add SPY
self.tickers = tickers
tickers.append('SPY')
tickers.sort()
# load data
ts = TimeSeries(key, output_format="pandas")
X = None
# loop over tickers
for ticker in tickers:
# load stock data from Alpha Vantage
tick_dat, _ = ts.get_monthly_adjusted(symbol=ticker)
# old and new columns
old_cols = ['5. adjusted close', '7. dividend amount']
new_cols = [ticker + '_PRC', ticker + '_DIV']
# select tick data
tick_dat = tick_dat[old_cols]
col_dict = dict(zip(old_cols, new_cols))
tick_dat = tick_dat.rename(columns=col_dict)
# reformat date
tick_dat.index = 100 * tick_dat.index.year + tick_dat.index.month
# meger to X list
opts = {'how': 'outer', 'left_index': True, 'right_index': True}
if X is None:
X = tick_dat.iloc[::-1]
else:
X = X.merge(tick_dat, **opts)
# drop
X.to_csv('_'.join(tickers) + '.csv')
# compute returns
for t in tickers:
X[t + '_RET'] = (X[t + '_PRC'] +
X[t + '_DIV']) / X[t + '_PRC'].shift() - 1.
X[t + '_DY'] = X[t + '_DIV'] / X[t + '_PRC'].shift()
X[t + '_CG'] = X[t + '_PRC'] / X[t + '_PRC'].shift() - 1.
# kill the first row (with the NAs)
X = X.loc[X.index[1:], ]
# store data frame
self.X = X
# column names
self.columns = [ticker + '_RET' for ticker in self.tickers]
# subset
idx = self.X.index[-h - 2:-2]
self.X = self.X.loc[idx]
# drop
if to_csv:
self.X.to_csv('_'.join(self.tickers) + '_JORDAN.csv')
# statistics
self.m = self.X[self.columns].mean().to_numpy()
self.S = self.X[self.columns].cov().to_numpy()
# matrix and its lu decomposition
self.N = len(self.tickers)
lu, piv = lu_factor(self.S)
self.Si1 = lu_solve((lu, piv), np.ones(self.N))
self.Sim = lu_solve((lu, piv), self.m)
a11 = np.ones(self.N) @ self.Si1
a21 = self.m @ self.Si1
a22 = self.m @ self.Sim
self.A = np.array([[a11, a21], [a21, a22]])
from alpha_vantage.timeseries import TimeSeries
import pandas as pd
# IEF
Ticker = ['VFINX', 'VINEX', 'VUSTX']
ts = TimeSeries(key='XAU63L4PGEZMXFRE', output_format='pandas')
for i in range(0, len(Ticker), 1):
ts = TimeSeries(key='XAU63L4PGEZMXFRE', output_format='pandas')
# data, meta_data = ts.get_daily(symbol=Ticker[i], outputsize='full')
data, meta_data = ts.get_monthly_adjusted(symbol=Ticker[i])
res = data.iloc[:,4]
res = res.to_frame()
res.columns = [Ticker[i]]
if i==0:
out = res
else:
out = out.join(res)
#data['close'].plot()
#plt.title('Intraday Times Series for the MSFT stock (1 min)')
#plt.show()
# Create a Pandas Excel writer using XlsxWriter as the engine.
writer = pd.ExcelWriter('/Users/xudongsong/FinQuant/Indices.xlsx', engine='xlsxwriter')
#Pull types can be 'intraday', 'daily', 'weekly', or 'monthly'
symbol = 'SPY'
pullType = 'intraday'
inter = '5min'
#Open a new timeseries object with the alpha vantage key code
ts = TimeSeries(key='1RJDU8R6RESLVE09', output_format='pandas')
#use the get_ function of the timeseries object with the appropriate period
if pullType == 'intraday':
data1, meta_data1 = ts.get_intraday(symbol=symbol,
interval=inter,
outputsize='full')
elif pullType == 'daily':
data1, meta_data1 = ts.get_daily_adjusted(symbol=symbol, outputsize='full')
elif pullType == 'weekly':
data1, meta_data1 = ts.get_weekly_adjusted(symbol=symbol,
outputsize='full')
elif pullType == 'monthly':
data1, meta_data1 = ts.get_monthly_adjusted(symbol=symbol,
outputsize='full')
else:
print('Please enter a valid pull type')
data1.columns = ['Open', 'High', 'Low', 'Close', 'Volume']
#Save the dataframe in csv format
data1.to_csv(directory + symbol + '.csv')
#Notify the user when complete
print('Saved csv')
import pandas as pd
import numpy as np
from alpha_vantage.timeseries import TimeSeries
from scipy import stats
api_key = 'URRP3SWEDY8WA3M4'
ts = TimeSeries(key=api_key, output_format='pandas')
print("Enter a ticker symbol: ")
stock = input()
print("Pick a Time frame in months (recommended = 60)")
time_frame = int(input())
gspc_data, gspc_meta_data = ts.get_monthly_adjusted(symbol='^GSPC')
data, meta_data = ts.get_monthly_adjusted(symbol=stock)
stock_df = pd.DataFrame(data['5. adjusted close'][:time_frame])
gspc_df = pd.DataFrame(gspc_data['5. adjusted close'][:time_frame])
# Calculates beta using the slope of a simple linear regression
def calc_beta(dependent_var, independent_var):
monthly_prices = pd.concat([dependent_var, independent_var], axis=1)
monthly_prices.columns = ['stock', '^GSPC']
monthly_returns = monthly_prices.pct_change(1)
clean_monthly_returns = monthly_returns.dropna(axis=0)
gspc = clean_monthly_returns['^GSPC']
stock = clean_monthly_returns['stock']
def timeSeries(API_key, ticker):
from alpha_vantage.timeseries import TimeSeries
import matplotlib.pyplot as plt
import mplfinance as mpf
ts=TimeSeries(key=API_key, output_format='pandas')
option=input('1. Intraday\n2. Daily\n3. Weekly\n4. Monthly\n5. Quote Endpoint\n6. Search Endpoint\n').lower()
if option=='intraday' or option=='1':
interval=int(input("Enter the interval:\n\t1. 1 minute\n\t2. 5 minutes\n\t3. 15 minutes\n\t4. 30 minutes\n\t5. 60 minutes\n"))
inter=['','1min','5min','15min','30min','60min']
data=ts.get_intraday(symbol=ticker, interval=inter[interval])[0]
data.columns = ['Open', 'High', 'Low', 'Close', 'Volume']
data.index.name = "Date"
mpf.plot(data,
type='candle',
title=f"Intraday Time series for the {ticker} stock {inter[interval]}",
mav=(20),
volume=True,
tight_layout=True,
style='yahoo')
return data
elif option=='daily' or option=='2':
data=ts.get_daily_adjusted(symbol=ticker)[0]
data.columns = ['Open', 'High', 'Low', 'Close', 'Adjusted_close','Volume','Dividend Amount','Split Coefficient']
data.index.name = "Date"
mpf.plot(data,
type='candle',
title=f'Daily Time series for the {ticker} stock',
mav=(20),
volume=True,
tight_layout=True,
style='yahoo')
return data
elif option=='weekly' or option=='3':
data=ts.get_weekly_adjusted(symbol=ticker)[0]
data.columns = ['Open', 'High', 'Low', 'Close', 'Adjusted_close','Volume','Dividend Amount']
data.index.name = "Date"
mpf.plot(data,
type='candle',
title=f'Weekly Time series for the {ticker} stock',
mav=(20),
volume=True,
tight_layout=True,
style='yahoo')
return data
elif option=='monthly' or option=='4':
data=ts.get_monthly_adjusted(symbol=ticker)[0]
data.columns = ['Open', 'High', 'Low', 'Close', 'Adjusted_close','Volume','Dividend Amount']
data.index.name = "Date"
mpf.plot(data,
type='candle',
title=f'Monthly Time series for the {ticker} stock',
mav=(20),
volume=True,
tight_layout=True,
style='yahoo')
return data
elif option=='quote endpoint' or option=='5':
data=ts.get_quote_endpoint(symbol=ticker)[0]
return data
elif option=='search endpoint' or option=='6':
keywords=input('Enter the Name of the Stock:\n')
data=ts.get_symbol_search(keywords=keywords)[0]
return data
else:
print("CANNOT RECOGNIZE")
class Datasource(AbcDatasource):
"""alphavantage.com datasource provider.
Load data from website alphavantage.
Attributes:
api_key (str): alphavantage API key
Usage::
>>> from Mercury_contrib.datasources import AlphaVantage
>>> datasource = AlphaVantage('api_key')
>>> dataframe = datasource.get_timeseries(
from_date=datetime(2019, 12, 1, 9, 00, 00),
to_date=datetime(2019, 12, 15, 23, 00, 00),
instrument="MSFT",
timeframe=Timeframe.M5,
)
"""
def __init__(self, api_key: str) -> None:
"""Class initialization.
Args:
api_key: alphavantage api key
"""
self.api_key = api_key
self.ts = AvTimeseries(key=api_key,
output_format="pandas",
indexing_type="date")
@property
def colsmap(self) -> Dict[str, str]:
"""Columns mapping dictionary.
Provide a mapping to translate raw time series columns name
to standardized naming convention.
Expect standard names like "open", "high", "low", "close", "adj_close"
and "volume".
"""
return {
"1. open": "open",
"2. high": "high",
"3. low": "low",
"4. close": "close",
"5. volume": "volume",
}
def get_timeseries(self, from_date: datetime, to_date: datetime,
instrument: str, timeframe: Timeframe) -> Timeseries:
"""Retrieve a given timeseries from the datasource.
Args:
from_date: timeseries starting date.
to_date: timeseries last date.
instrument: target instrument.
timeframe: target timeframe.
Returns:
An Mercury Timeseries.
Raises:
IndexError: The requested time range cannot be satisfied.
"""
if timeframe is Timeframe.H4:
raise ValueError("H4 interval not supported")
interval = int(timeframe.value / 60)
if interval <= 60:
data, meta_data = self.ts.get_intraday(symbol=instrument,
interval=f"{interval}min",
outputsize="full")
if timeframe is Timeframe.D1:
data, meta_data = self.ts.get_daily_adjusted(symbol=instrument,
outputsize="full")
if timeframe is Timeframe.W1:
data, meta_data = self.ts.get_weekly_adjusted(symbol=instrument)
if timeframe is Timeframe.MN:
data, meta_data = self.ts.get_monthly_adjusted(symbol=instrument)
return Timeseries(instrument, timeframe, data)
import numpy as np
import time
sp = pd.DataFrame(pd.read_csv('./constituents_csv.csv'))
key = '9AD6SV02MT4Z7G8W'
ts = TimeSeries(key, output_format='pandas')
# aapl, meta = ts.get_monthly_adjusted(symbol='AAPL')
# print(aapl[aapl.index >= '2015'])
results = []
for ticker in sp['Symbol'][:100]:
print(ticker)
try:
res, meta = ts.get_monthly_adjusted(symbol=ticker)
res['ticker'] = ticker
for i in range(2015, 2021): # up to 2021
try:
year = res[res.index.year == i]
open_ = year[year.index.month == 1]['1. open'].values
close = year[year.index.month ==
12]['5. adjusted close'].values
yearly_adj_close = close - open_
yearly_change = yearly_adj_close / open_
results.append({
'year': i,
'ticker': ticker,
'yearly adjsuted close': yearly_adj_close[0],
'yearly percent change': yearly_change[0],
'year open': open_[0],
class AlphaVantageClient:
def __init__(self, api_key=None):
if api_key is None:
default_api_key = utils.get_api_key('AlphaVantage')
if default_api_key is None:
raise ValueError('No AlphaVantage API Key found.')
else:
self.ts = TimeSeries(key=default_api_key,
output_format='pandas')
else:
self.ts = TimeSeries(key=api_key, output_format='pandas')
def get_data(self,
symbol,
freq='daily',
adjusted=True,
interval='15min',
outputsize='full'):
""" Return time series in pandas formet.
Keyword Arguments:
symbol: the symbol for the equity we want to get its data
freq: frequency of data, supported values are 'daily', 'weekly', 'monthly' (default 'daily'). Currently not support for 'intraday'
adjusted: adjust the OHLC value (default True)
interval: time interval between two conscutive values, used when freq is intraday
supported values are '1min', '5min', '15min', '30min', '60min'
(default '15min')
outputsize: The size of the call, supported values are
'compact' and 'full; the first returns the last 100 points in the
data series, and 'full' returns the full-length intraday times
series, commonly above 1MB (default 'compact')
"""
key = '{}-{}'.format(freq, adjusted)
# elif key == 'intraday-True':
# data, _ = self.ts.get_intraday(symbol=symbol, interval=interval, outputsize=outputsize)
# elif key == 'intraday-False':
# data, _ = self.ts.get_intraday(symbol=symbol, interval=interval, outputsize=outputsize)
if key == 'daily-True':
data, _ = self.ts.get_daily_adjusted(symbol=symbol,
outputsize=outputsize)
elif key == 'daily-False':
data, _ = self.ts.get_daily(symbol=symbol, outputsize=outputsize)
elif key == 'weekly-True':
data, _ = self.ts.get_weekly_adjusted(symbol=symbol)
elif key == 'weekly-False':
data, _ = self.ts.get_weekly(symbol=symbol)
elif key == 'monthly-True':
data, _ = self.ts.get_monthly_adjusted(symbol=symbol)
elif key == 'monthly-False':
data, _ = self.ts.get_monthly(symbol=symbol)
else:
raise Warning(
'Freq: {} or Adjusted: {} is not valid. Default to Daily Adjusted.'
)
data, _ = self.ts.get_daily_adjusted(symbol=symbol,
outputsize=outputsize)
if freq == 'intraday':
data.columns = ['Open', 'High', 'Low', 'Close', 'Volume']
else:
columns_name = [
'Open', 'High', 'Low', 'Close', 'Adj Close', 'Volume',
'Dividends', 'Stock Splits'
]
data.columns = columns_name[:len(data.columns)]
data = data.rename(index={'date': 'Date'})
return data.sort_index(ascending=True)
def get_latest_data(self, symbol):
""" Return the latest price and volume information for a security of your choice
Keyword Arguments:
symbol: the symbol for the equity we want to get its data
"""
data, _ = self.ts.get_quote_endpoint(symbol=symbol)
columns_name = [
'Open', 'High', 'Low', 'Price', 'Volume', 'Date', 'Previous Close',
'Change', 'Change Pct'
]
data = data.iloc[:, 1:]
data.columns = columns_name
data = data.set_index(['Date'])
return data
class AlphaVantageHandle(DataAPIBase):
RAPIDAPI_KEY = "de7dba73d8msh6207eff68e3f134p10e7d1jsn87fd4c7d47de"
ALPHA_VANTAGE_KEY = "EL89QWXFIKG17CEH"
ALPHA_VANTAGE_PRIMIUM_KEY = "BO5YJYOVZPVLML38"
API_TIME_LIMIT = 70 # The limit unit for trading in seconds
API_CALL_LIMIT = 30 # The limit of number of calls per limit unit
def __init__(self,
interval=None,
symbol=None,
use_rapid=False,
skip_data_init=False,
outputsize="full"):
super(AlphaVantageHandle, self).__init__()
self.log = logging.getLogger("Alpha Vantage API")
self._outputsize = outputsize
self.api_time_queue = Queue()
# Initialize alpha vantage time series
if use_rapid:
self.time_series = TimeSeries(key=self.RAPIDAPI_KEY,
output_format="pandas",
rapidapi=True)
else:
self.time_series = TimeSeries(key=self.ALPHA_VANTAGE_PRIMIUM_KEY,
output_format="pandas")
self.tech_indicators = TechIndicators(
key=self.ALPHA_VANTAGE_PRIMIUM_KEY, output_format='pandas')
if not skip_data_init:
# Set the symbol and interval for the handle
self.update_symbol_interval(symbol=symbol, interval=interval)
# Fetch time series data
self.log.info(
"Downloading time series and technical indicator data from alpha vantage:\n "
" symbol: %s\n"
" interval: %s\n", self._symbol, self._interval)
self.update_all_data()
self.log.info("Data downloaded")
def update_symbol_interval(self,
symbol=None,
interval=None,
force_update=False):
"""
Update the symbol and interval for the handle
"""
if symbol == None or (symbol != "keep" and len(symbol) < 1):
self.log.error("Invalid symbol: %s", symbol)
raise Exception("Invalid symbol!")
if self._symbol is not None:
force_update = True
if symbol != "keep":
self._symbol = symbol
if interval not in INTERVAL_TYPE and interval != "keep":
self.log.error("Interval type %s is invalid. You must provide a type:\n " + \
"".join(iv + "\n " for iv in INTERVAL_TYPE), interval)
raise Exception("Invalid interval type!")
if self._interval is not None:
force_update = True
if interval != "keep":
self._interval = interval
if force_update:
self.update_all_data()
def update_all_data(self):
self.log.info("Updating time series and tech indicators data")
self.fetch_ts_data()
self.fetch_ti_data()
def _limited_api_wrapper(self, func):
time_queue = self.api_time_queue
time_limit = self.API_TIME_LIMIT
call_limit = self.API_CALL_LIMIT
def limited_api(*args, **kwargs):
if time_queue.empty():
time_queue.put(time.time())
else:
cur_time = time.time()
while not time_queue.empty():
if time_queue.queue[0] < cur_time - time_limit:
time_queue.get()
else:
break
if time_queue.qsize() >= call_limit:
time_delta = time.time() - time_queue.queue[0]
time.sleep(time_delta)
time_queue.get()
time_queue.put(time.time())
return func(*args, **kwargs)
return limited_api
def fetch_ts_data(self):
"""
Fetch time series data from alpha vantage based on the current data type
"""
if self._interval not in INTERVAL_TYPE:
self.log.error("Interval type %s is not supported!",
self._interval)
raise Exception("Interval type not supported!")
if self._interval in INTRA_DAY_TYPE:
self.ts_data, metadata = self.time_series.get_intraday(
symbol=self._symbol,
interval=self._interval,
outputsize=self._outputsize)
elif self._interval == "daily":
self.ts_data, metadata = self.time_series.get_daily_adjusted(
symbol=self._symbol, outputsize=self._outputsize)
elif self._interval == "weekly":
self.ts_data, metadata = self.time_series.get_weekly_adjusted(
symbol=self._symbol, outputsize=self._outputsize)
elif self._interval == "monthly":
self.ts_data, metadata = self.time_series.get_monthly_adjusted(
symbol=self._symbol, outputsize=self._outputsize)
else:
self.log.error("Interval type %s not implemented!", self._interval)
raise NotImplementedError
self.log.info("Fetched data with:\n"
" information: %(1. Information)s\n"
" symbol: %(2. Symbol)s\n"
" last refreshed: %(3. Last Refreshed)s" % metadata)
def fetch_ti_data(self):
"""
Fetch time indicator data from alpha vantage based on the current data type
"""
if self._interval not in INTERVAL_TYPE:
self.log.error("Interval type %s is not supported!",
self._interval)
raise Exception("Interval type not supported!")
for ti_type in TI_TYPE:
self.log.info("Fetching ti data for %s", ti_type)
ti_data = self._fetch_ti_data_helper(ti_type)
if not ti_data.empty:
self.ti_data = pd.concat([self.ti_data, ti_data], axis=1)
def _fetch_ti_data_helper(self, ti_type):
"""
Helper function to get data for a specific technical indicator
We are currently getting high and low for each interval
"""
ti_data = pd.DataFrame()
if ti_type == "SMA":
get_sma = self._limited_api_wrapper(self.tech_indicators.get_sma)
data_high, metadata = get_sma(symbol=self._symbol,
interval=self._interval,
series_type="high")
data_low, metadata = get_sma(symbol=self._symbol,
interval=self._interval,
series_type="low")
ti_data = pd.concat([data_high, data_low], axis=1)
ti_data.columns = ["SMA_H", "SMA_L"]
elif ti_type == "EMA":
get_ema = self._limited_api_wrapper(self.tech_indicators.get_ema)
data_high, metadata = get_ema(symbol=self._symbol,
interval=self._interval,
series_type="high")
data_low, metadata = get_ema(symbol=self._symbol,
interval=self._interval,
series_type="low")
ti_data = pd.concat([data_high, data_low], axis=1)
ti_data.columns = ["EMA_H", "EMA_L"]
elif ti_type == "VWAP":
if self._interval not in INTRA_DAY_TYPE:
self.log.error(
"VWAP only support intra day data. No data gathered")
else:
get_vwap = self._limited_api_wrapper(
self.tech_indicators.get_vwap)
data, metadata = get_vwap(symbol=self._symbol,
interval=self._interval)
ti_data = data.copy()
elif ti_type == "MACD":
get_macd = self._limited_api_wrapper(self.tech_indicators.get_macd)
data_high, metadata = get_macd(symbol=self._symbol,
interval=self._interval,
series_type="high")
data_low, metadata = get_macd(symbol=self._symbol,
interval=self._interval,
series_type="low")
ti_data = pd.concat([
data_high[["MACD_Signal", "MACD"]],
data_low[["MACD_Signal", "MACD"]]
],
axis=1)
ti_data.columns = [
"MACD_Signal_H", "MACD_H", "MACD_Signal_L", "MACD_L"
]
elif ti_type == "STOCH":
get_stoch = self._limited_api_wrapper(
self.tech_indicators.get_stoch)
data, metadata = get_stoch(symbol=self._symbol,
interval=self._interval)
ti_data = data.copy()
elif ti_type == "RSI":
get_rsi = self._limited_api_wrapper(self.tech_indicators.get_rsi)
data_high, metadata = get_rsi(symbol=self._symbol,
interval=self._interval,
series_type="high")
data_low, metadata = get_rsi(symbol=self._symbol,
interval=self._interval,
series_type="low")
ti_data = pd.concat([data_high, data_low], axis=1)
ti_data.columns = ["RSI_H", "RSI_L"]
elif ti_type == "ADX":
get_adx = self._limited_api_wrapper(self.tech_indicators.get_adx)
data, metadata = get_adx(symbol=self._symbol,
interval=self._interval)
ti_data = data.copy()
elif ti_type == "CCI":
get_cci = self._limited_api_wrapper(self.tech_indicators.get_cci)
data, metadata = get_cci(symbol=self._symbol,
interval=self._interval)
ti_data = data.copy()
elif ti_type == "AROON":
get_aroon = self._limited_api_wrapper(
self.tech_indicators.get_aroon)
data_high, metadata = get_aroon(symbol=self._symbol,
interval=self._interval,
series_type="high")
data_low, metadata = get_aroon(symbol=self._symbol,
interval=self._interval,
series_type="low")
ti_data = pd.concat([data_high, data_low], axis=1)
ti_data.columns = [
"Aroon_Down_H", "Aroon_Up_H", "Aroon_Down_L", "Aroon_Up_L"
]
elif ti_type == "BBANDS":
get_bbands = self._limited_api_wrapper(
self.tech_indicators.get_bbands)
# We want both SMA and EMA features
data_high_sma, metadata = get_bbands(symbol=self._symbol,
interval=self._interval,
series_type="high")
data_low_sma, metadata = get_bbands(symbol=self._symbol,
interval=self._interval,
series_type="low")
data_high_ema, metadata = get_bbands(symbol=self._symbol,
interval=self._interval,
series_type="high",
matype=1)
data_low_ema, metadata = get_bbands(symbol=self._symbol,
interval=self._interval,
series_type="low",
matype=1)
ti_data = pd.concat(
[data_high_sma, data_high_ema, data_low_sma, data_low_ema],
axis=1)
ti_data.columns = [
"BBANDS_Upper_SMA_H", "BBANDS_Lower_SMA_H",
"BBANDS_Middle_SMA_H", "BBANDS_Upper_EMA_H",
"BBANDS_Lower_EMA_H", "BBANDS_Middle_EMA_H",
"BBANDS_Upper_SMA_L", "BBANDS_Lower_SMA_L",
"BBANDS_Middle_SMA_L", "BBANDS_Upper_EMA_L",
"BBANDS_Lower_EMA_L", "BBANDS_Middle_EMA_L"
]
elif ti_type == "AD":
get_ad = self._limited_api_wrapper(self.tech_indicators.get_ad)
data, metadata = get_ad(symbol=self._symbol,
interval=self._interval)
ti_data = data.copy()
elif ti_type == "OBV":
get_obv = self._limited_api_wrapper(self.tech_indicators.get_obv)
data, metadata = get_obv(symbol=self._symbol,
interval=self._interval)
ti_data = data.copy()
else:
self.log.error("Technical indicator type %s not implemented!",
ti_type)
raise NotImplementedError
return ti_data
class DataFetcher:
"""
Provides abstractions for:
1. fetch data from AlphaVantage API
2. saves data to ../data/api_data
Momentarily only compatible with the AlphaVantage API.
"""
def __init__(self, api_key):
self._api_key = api_key
self.ts = TimeSeries(key=self._api_key, output_format="pandas")
def fetch_data(self, tickers, time_window):
# format tickers as list
tickers = [tickers] if not isinstance(tickers, list) else tickers
try:
if len(tickers) <= 5:
for ticker in tickers:
ticker = ticker.lower()
if time_window == "daily":
data, meta_data = self.ts.get_daily_adjusted(
symbol=ticker, outputsize="full")
elif time_window == "weekly":
data, meta_data = self.ts.get_weekly_adjusted(
symbol=ticker, outputsize="full")
elif time_window == "monthly":
data, meta_data = self.ts.get_monthly_adjusted(
symbol=ticker, outputsize="full")
else:
# time_window parameter not supported, raise exception
raise TypeError(
f"The following time_window: '{time_window}' is not supported momentarily"
)
# format and convert index to datetime
data.index = pd.to_datetime(
data.index.strftime("%Y-%m-%d"))
data = data.sort_index(ascending=True)
# remove numbers from column names
data = data.rename(
columns={
col: re.sub(r"([0-9]\. )", "", col)
for col in data.columns
})
data = data.rename(
columns={col: col.lower()
for col in data.columns})
# create api_data directory
if not path.exists(path.join("..", "data", "api_data")):
makedirs(path.join("..", "data", "api_data"))
# save data to ./data/api_data
save_path = path.join(path.dirname(path.abspath(__file__)),
"..", "data", "api_data",
f"{ticker}_{time_window}.csv")
data.to_csv(save_path)
return True
else:
# no more than 5 API calls (tickers) per minute, raise exception
raise ValueError(
"No more than 5 API calls/minute supported! Please provide a ticker list <= 5"
)
except (ValueError, TypeError) as e:
traceback.print_exc()
print(e)
sys.exit(0)
class REST(object):
def __init__(self, api_key):
self._api_key = get_alpha_vantage_credentials(api_key)
self._session = requests.Session()
self._timeseries = TimeSeries(key=self._api_key)
self._cryptocurrencies = CryptoCurrencies(key=self._api_key)
self._foreignexchange = ForeignExchange(key=self._api_key)
self._sectorperformance = SectorPerformances(key=self._api_key)
self._techindicators = TechIndicators(key=self._api_key)
def _request(self, method, params=None):
url = 'https://www.alphavantage.co/query?'
params = params or {}
params['apikey'] = self._api_key
resp = self._session.request(method, url, params=params)
resp.raise_for_status()
return resp.json()
def get(self, params=None):
''' Customizable endpoint, where you can pass all
keywords/paramters from the documentation:
https://www.alphavantage.co/documentation/#
Returns:
pandas, csv, or json
'''
return self._request('GET', params=params)
def historic_quotes(self, symbol, adjusted=False, outputsize='full', cadence='daily', output_format=None):
''' Returns the one of the TIME_SERIES_* endpoints of the Alpha Vantage API.
Params:
symbol: The ticker to return
adjusted: Return the adjusted prices
cadence: Choose between ['daily', 'weekly', 'monthly'], to return the cadence
output_format: Choose between['json', 'csv', 'pandas']
Returns:
pandas, csv, or json
'''
if output_format:
self._timeseries.output_format = output_format
if cadence == 'daily':
data, _ = self._timeseries.get_daily_adjusted(
symbol=symbol, outputsize=outputsize) if adjusted else self._timeseries.get_daily(symbol=symbol, outputsize=outputsize)
if cadence == 'weekly':
data, _ = self._timeseries.get_weekly_adjusted(
symbol=symbol) if adjusted else self._timeseries.get_weekly(symbol=symbol)
if cadence == 'monthly':
data, _ = self._timeseries.get_monthly_adjusted(
symbol=symbol) if adjusted else self._timeseries.get_monthly(symbol=symbol)
return data
def intraday_quotes(self, symbol, interval='5min', outputsize='full', output_format=None):
''' Returns the TIME_SERIES_INTRADAY endpoint of the Alpha Vantage API.
Params:
symbol: The ticker to return
interval: Choose between['1min', '5min', '15min', '30min', '60min']
output_format: Choose between['json', 'csv', 'pandas']
Returns:
pandas, csv, or json
'''
if output_format:
self._timeseries.output_format = output_format
data, _ = self._timeseries.get_intraday(
symbol=symbol, interval=interval, outputsize=outputsize)
return data
def current_quote(self, symbol):
''' Returns the GLOBAL_QUOTE endpoint
of the Alpha Vantage API.
Params:
symbol: The ticker to return
output_format: Choose between['json', 'csv', 'pandas']
Returns:
pandas, csv, or json
'''
data, _ = self._timeseries.get_quote_endpoint(symbol=symbol)
return data
def last_quote(self, symbol):
return self.current_quote(symbol)
def company(self, symbol, datatype='json'):
return self.search_endpoint(symbol, datatype=datatype)
def search_endpoint(self, keywords, datatype='json'):
'''Search endpoint returns a list of possible companies
that correspond to keywords
Params:
datatype: csv, json, or pandas
keywords: ex. keywords=microsoft
Returns:
pandas, csv, or json
'''
params = {'function': 'SYMBOL_SEARCH',
'keywords': keywords, 'datatype': datatype}
return self.get(params)
def historic_fx_quotes(self, from_symbol, to_symbol, outputsize='full', cadence='daily', output_format=None):
''' Returns the one of the FX_* endpoints of the Alpha Vantage API.
Params:
from_currency: The symbol to convert
to_currency: The symbol to convert to
cadence: Choose between ['daily', 'weekly', 'monthly'], to return the cadence
output_format: Choose between['json', 'csv', 'pandas']
Returns:
pandas, csv, or json
'''
if output_format:
self._foreignexchange.output_format = output_format
if cadence == 'daily':
data, _ = self._foreignexchange.get_currency_exchange_daily(
from_symbol=from_symbol, to_symbol=to_symbol, outputsize=outputsize)
if cadence == 'weekly':
data, _ = self._foreignexchange.get_currency_exchange_weekly(
from_symbol=from_symbol, to_symbol=to_symbol, outputsize=outputsize)
if cadence == 'monthly':
data, _ = self._foreignexchange.get_currency_exchange_monthly(
from_symbol=from_symbol, to_symbol=to_symbol, utputsize=outputsize)
return data
def intraday_fx_quotes(self, from_symbol, to_symbol, interval='5min', outputsize='full', output_format=None):
''' Returns the FX_INTRADAY endpoint of the Alpha Vantage API.
Params:
from_currency: The symbol to convert
to_currency: The symbol to convert to
interval: Choose between['1min', '5min', '15min', '30min', '60min']
output_format: Choose between['json', 'csv', 'pandas']
Returns:
pandas, csv, or json
'''
if output_format:
self._foreignexchange.output_format = output_format
data, _ = self._foreignexchange.get_currency_exchange_intraday(
from_symbol=from_symbol, to_symbol=to_symbol, interval=interval, outputsize=outputsize)
return data
def exchange_rate(self, from_currency, to_currency):
''' Returns the exchange rate of two currencies, digital or physical.
CURRENCY_EXCHANGE_RATE endpoint of the Alpha Vantage API
Params:
from_currency: The symbol to convert
to_currency: The symbol to convert to
Returns:
json
'''
params = {'function': "CURRENCY_EXCHANGE_RATE",
'from_currency': from_currency, 'to_currency': to_currency}
data = self.get(params)
return data
def historic_cryptocurrency_quotes(self, symbol, market, cadence='daily', output_format=None):
''' Returns the one of the DIGITAL_CURRENCY_* endpoints of the Alpha Vantage API.
Params:
symbol: The cryptocurrency to return
market: The market it's being sold on
cadence: Choose between ['daily', 'weekly', 'monthly'], to return the cadence
output_format: Choose between['json', 'csv', 'pandas']
Returns:
pandas, csv, or json
'''
if output_format:
self._cryptocurrencies.output_format = output_format
if cadence == 'daily':
data, _ = self._cryptocurrencies.get_digital_currency_daily(
symbol=symbol, market=market)
if cadence == 'weekly':
data, _ = self._cryptocurrencies.get_digital_currency_weekly(
symbol=symbol, market=market)
if cadence == 'monthly':
data, _ = self._cryptocurrencies.get_digital_currency_monthly(
symbol=symbol, market=market)
return data
def techindicators(self, techindicator='SMA', output_format='json', **kwargs):
''' Returns the one of the technical indicator endpoints of the Alpha Vantage API.
Params:
techindicator: The technical indicator of choice
params: Each technical indicator has additional optional parameters
Returns:
pandas, csv, or json
'''
if output_format:
self._techindicators.output_format = output_format
params = {'function': techindicator}
for key, value in kwargs.items():
params[key] = value
data = self.get(params)
return data
def sector(self):
''' Returns the sector performances
Returns:
pandas, csv, or json
'''
data, _ = self._sectorperformance.get_sector()
return data
def get_raw_prices(self):
if (self.fetch_data == 'pdr'):
self.attrs = [
'Adj Close', 'Close', 'High', 'Open', 'Low', 'Volume'
]
self.symbs = self.tickers_names.index
self.midx = pd.MultiIndex.from_product([self.attrs, self.symbs],
names=('Attributes',
'Symbols'))
if (self.new_db_raw_prices):
dt_raw_prices = pdr.DataReader(self.tickers_names, 'yahoo',
self.start_date, self.end_date)
dt_raw_prices['Dates'] = pd.to_datetime(dt_raw_prices.index,
format='%Y-%m-%d')
engine = create_engine("sqlite:///" + self.output_directory +
"/dt_raw_prices_pdr.db",
echo=False)
dt_raw_prices.to_sql('dt_raw_prices',
engine,
if_exists='replace',
index=False)
else:
engine = create_engine("sqlite:///" + self.output_directory +
"/dt_raw_prices_pdr.db",
echo=False)
self.dt_raw_prices = pd.read_sql_table(
'dt_raw_prices',
con=engine,
parse_dates={'Dates': {
'format': '%Y-%m-%d'
}})
self.dt_raw_prices.rename(columns={"('Dates', '')": 'Dates'},
inplace=True)
self.dt_raw_prices.set_index('Dates', inplace=True)
self.dt_raw_prices.columns = self.midx
self.dt_select = self.dt_raw_prices[[self.ohlc, 'Volume']]
# print(self.dt_raw_prices)
# print(self.dt_select)
elif (self.fetch_data == 'alphav'):
self.symbs = [
'NVDA', 'AMZN', 'TSLA', 'MRNA', 'AAPL'
] # Helper.nasdaq100_tickers(self.url_nasdaq).index.to_list()
if (self.freq == 'monthly'):
self.attrs = [
'Open', 'High', 'Low', 'Close', 'Adj Close', 'Volume',
'Dividend'
]
elif (self.freq == 'daily'):
self.attrs = [
'Open', 'High', 'Low', 'Close', 'Adj Close', 'Volume',
'Dividend', 'Split coeff'
]
elif (self.freq == 'intraday'):
self.attrs = ['Open', 'High', 'Low', 'Close', 'Volume']
self.midx = pd.MultiIndex.from_product([self.symbs, self.attrs],
names=('Symbols',
'Attributes'))
if (self.new_db_alphav_prices):
api_key = os.getenv('ALPHAVANTAGE_API_KEY')
ts = TimeSeries(key=api_key, output_format='pandas')
data_all = []
meta_data_all = []
if (self.freq == 'monthly'):
for i, el in enumerate(self.symbs):
data, meta_data = ts.get_monthly_adjusted(symbol=el)
data.columns = self.attrs
data_all.append(data)
meta_data_all.append(meta_data)
elif (self.freq == 'daily'):
for i, el in enumerate(self.symbs):
data, meta_data = ts.get_daily_adjusted(symbol=el)
data.columns = self.attrs
data_all.append(data)
meta_data_all.append(meta_data)
elif (self.freq == 'intraday'):
for i, el in enumerate(self.symbs):
data, meta_data = ts.get_intraday(symbol=el,
interval='60min',
outputsize='compact')
data.columns = self.attrs
data_all.append(data)
meta_data_all.append(meta_data)
self.dt_raw_prices = pd.concat(data_all, axis=1)
self.dt_raw_prices.columns = self.midx
self.dt_raw_prices = self.dt_raw_prices[::-1]
self.dt_raw_prices['Dates'] = pd.to_datetime(
self.dt_raw_prices.index, format='%Y-%m-%d')
engine = create_engine("sqlite:///" + self.output_directory +
"/dt_raw_prices_alv.db",
echo=False)
self.dt_raw_prices.to_sql('dt_raw_prices',
engine,
if_exists='replace',
index=False)
else:
engine = create_engine("sqlite:///" + self.output_directory +
"/dt_raw_prices_alv.db",
echo=False)
self.dt_raw_prices = pd.read_sql_table(
'dt_raw_prices',
con=engine,
parse_dates={'Dates': {
'format': '%Y-%m-%d'
}})
self.dt_raw_prices.rename(columns={"('Dates', '')": 'Dates'},
inplace=True)
self.dt_raw_prices.set_index('Dates', inplace=True)
self.dt_raw_prices.columns = self.midx
self.dt_raw_prices.index = pd.to_datetime(self.dt_raw_prices.index)
self.dt_raw_prices = self.dt_raw_prices.swaplevel(0, 1,
1).sort_index(1)
# select the tickers based on ohlc parameters
if (self.freq == 'monthly' or self.freq == 'daily'):
self.dt_select = self.dt_raw_prices.loc[:,
self.dt_raw_prices.
columns.
get_level_values(0).
isin([self.ohlc] +
['Volume'])]
elif (self.freq == 'intraday'):
self.dt_select = self.dt_raw_prices.loc[:,
self.dt_raw_prices.
columns.
get_level_values(0).
isin([
'Close', 'Volume'
])]
def show_frontier_simple(self):
symbs = [self.rr_symb1,self.rr_symb2]
if(self.freq == 'monthly'):
attrs = ['Open','High','Low','Close','Adj Close','Volume','Dividend']
elif(self.freq == 'daily'):
attrs = ['Open','High','Low','Close','Adj Close','Volume','Dividend','Split coeff']
midx = pd.MultiIndex.from_product([symbs,attrs],names=('Symbols','Attributes'))
if(self.new_db_alphav_prices):
api_key = os.getenv('ALPHAVANTAGE_API_KEY')
ts = TimeSeries(key=api_key, output_format='pandas')
if(self.freq == 'monthly'):
data1, meta_data1 = ts.get_monthly_adjusted(symbol=self.rr_symb1)
data2, meta_data2 = ts.get_monthly_adjusted(symbol=self.rr_symb2)
elif(self.freq == 'daily'):
data1, meta_data1 = ts.get_daily_adjusted(symbol=self.rr_symb1)
data2, meta_data2 = ts.get_daily_adjusted(symbol=self.rr_symb2)
data1.columns = attrs
data2.columns = attrs
dt_alphav_prices = pd.concat([data1,data2],axis=1)
dt_alphav_prices.columns = midx
dt_alphav_prices = dt_alphav_prices[::-1]
dt_alphav_prices['Dates'] = pd.to_datetime(dt_alphav_prices.index,format='%Y-%m-%d')
engine = create_engine("sqlite:///" + self.output_directory + "/dt_alphav_prices.db", echo=False)
dt_alphav_prices.to_sql(
'dt_alphav_prices',
engine,
if_exists='replace',
index=False
)
else:
engine = create_engine("sqlite:///" + self.output_directory + "/dt_alphav_prices.db", echo=False)
self.dt_alphav_prices = pd.read_sql_table(
'dt_alphav_prices',
con=engine,
parse_dates={'Dates': {'format': '%Y-%m-%d'}}
)
self.dt_alphav_prices.rename(columns={"('Dates', '')":'Dates'},inplace=True)
self.dt_alphav_prices.set_index('Dates',inplace=True)
self.dt_alphav_prices.columns = midx
returns1 = self.dt_alphav_prices[(self.rr_symb1,'Adj Close')].pct_change().fillna(0)
returns2 = self.dt_alphav_prices[(self.rr_symb2,'Adj Close')].pct_change().fillna(0)
if(len(returns1) > len(returns2)):
returns1 = returns1[-len(returns2):]
if(len(returns2) > len(returns1)):
returns2 = returns2[-len(returns1):]
mean_returns1 = np.mean(returns1)
variance1 = np.var(returns1)
standard_deviation1 = np.sqrt(variance1)
mean_returns2 = np.mean(returns2)
variance2 = np.var(returns2)
standard_deviation2 = np.sqrt(variance2)
correlation = np.corrcoef(returns1, returns2)[0][1]
print(f'Correlation = {correlation}')
weights = []
for n in range(0, 101):
weights.append((1 - 0.01 * n, 0 + 0.01 * n))
returns = []
standard_deviations = []
portfolio_50_50_standard_deviation = None
portfolio_50_50_returns = None
plt.figure(figsize=(32,20))
for w1, w2 in weights:
returns.append(w1 * mean_returns1 + w2 * mean_returns2)
variance = w1**2 * standard_deviation1**2 + w2**2 * standard_deviation2**2 + \
2 * w1 * w2 * standard_deviation1 * standard_deviation2 * correlation
standard_deviation = np.sqrt(variance)
standard_deviations.append(standard_deviation)
plt.scatter(standard_deviations[-1], returns[-1], color='#007bff')
if w1 == 0.5 and w2 == 0.5:
portfolio_50_50_standard_deviation = standard_deviations[-1]
portfolio_50_50_returns = returns[-1]
plt.scatter(portfolio_50_50_standard_deviation,
portfolio_50_50_returns, marker='x', color='red', alpha=1, s=320)
x_padding = np.average(standard_deviations) / 25
plt.xlim(min(standard_deviations) - x_padding,
max(standard_deviations) + x_padding)
y_padding = np.average(returns) / 25
plt.ylim(min(returns) - y_padding, max(returns) + y_padding)
plt.gca().set_xticks(plt.gca().get_xticks().tolist()) # remove in the future - placed to avoid warning - it is a bug from matplotlib 3.3.1
plt.gca().set_xticklabels(['{:.2f}%'.format(x*100) for x in plt.gca().get_xticks()])
plt.gca().set_yticks(plt.gca().get_yticks().tolist()) # remove in the future - placed to avoid warning - it is a bug from matplotlib 3.3.1
plt.gca().set_yticklabels(['{:.2f}%'.format(y*100) for y in plt.gca().get_yticks()])
plt.title(f'Efficient Frontier ({self.rr_symb1.upper()} and {self.rr_symb2.upper()})')
plt.xlabel('Risk (' + self.freq.capitalize() + ')')
plt.ylabel('Return (' + self.freq.capitalize() + ')')
plt.show()
symbol=symbol, outputsize='compact')
elif choice == 4:
data, meta_data = ts.get_weekly(
symbol=symbol)
elif choice == 5:
data, meta_data = ts.get_weekly_adjusted(
symbol=symbol)
elif choice == 6:
data, meta_data = ts.get_monthly(
symbol=symbol)
elif choice == 7:
data, meta_data = ts.get_monthly_adjusted(
symbol=symbol)
print(f"\n\n{symbol}\n")
pprint(data.head(n))
graph = input("\nDo you want to plot a graph? (y/n) ")
if graph == 'y':
data['4. close'].plot()
if choice == 1:
plt.title(
f'{choices[choice]} Time Series for the {symbol} stock ({interval})')
else:
plt.title(
f'{choices[choice]} Time Series for the {symbol} stock')
plt.show()
