def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Alpha Vantage sensor."""
from alpha_vantage.timeseries import TimeSeries
from alpha_vantage.foreignexchange import ForeignExchange
api_key = config.get(CONF_API_KEY)
symbols = config.get(CONF_SYMBOLS)
timeseries = TimeSeries(key=api_key)
dev = []
for symbol in symbols:
try:
timeseries.get_intraday(symbol[CONF_SYMBOL])
except ValueError:
_LOGGER.error(
"API Key is not valid or symbol '%s' not known", symbol)
dev.append(AlphaVantageSensor(timeseries, symbol))
forex = ForeignExchange(key=api_key)
for conversion in config.get(CONF_FOREIGN_EXCHANGE):
from_cur = conversion.get(CONF_FROM)
to_cur = conversion.get(CONF_TO)
try:
forex.get_currency_exchange_rate(
from_currency=from_cur, to_currency=to_cur)
except ValueError as error:
_LOGGER.error(
"API Key is not valid or currencies '%s'/'%s' not known",
from_cur, to_cur)
_LOGGER.debug(str(error))
dev.append(AlphaVantageForeignExchange(forex, conversion))
add_devices(dev, True)
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Alpha Vantage sensor."""
from alpha_vantage.timeseries import TimeSeries
from alpha_vantage.foreignexchange import ForeignExchange
api_key = config.get(CONF_API_KEY)
symbols = config.get(CONF_SYMBOLS, [])
conversions = config.get(CONF_FOREIGN_EXCHANGE, [])
if not symbols and not conversions:
msg = 'Warning: No symbols or currencies configured.'
hass.components.persistent_notification.create(
msg, 'Sensor alpha_vantage')
_LOGGER.warning(msg)
return
timeseries = TimeSeries(key=api_key)
dev = []
for symbol in symbols:
try:
_LOGGER.debug("Configuring timeseries for symbols: %s",
symbol[CONF_SYMBOL])
timeseries.get_intraday(symbol[CONF_SYMBOL])
except ValueError:
_LOGGER.error(
"API Key is not valid or symbol '%s' not known", symbol)
dev.append(AlphaVantageSensor(timeseries, symbol))
forex = ForeignExchange(key=api_key)
for conversion in conversions:
from_cur = conversion.get(CONF_FROM)
to_cur = conversion.get(CONF_TO)
try:
_LOGGER.debug("Configuring forex %s - %s", from_cur, to_cur)
forex.get_currency_exchange_rate(
from_currency=from_cur, to_currency=to_cur)
except ValueError as error:
_LOGGER.error(
"API Key is not valid or currencies '%s'/'%s' not known",
from_cur, to_cur)
_LOGGER.debug(str(error))
dev.append(AlphaVantageForeignExchange(forex, conversion))
add_devices(dev, True)
_LOGGER.debug("Setup completed")
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Alpha Vantage sensor."""
from alpha_vantage.timeseries import TimeSeries
api_key = config.get(CONF_API_KEY)
symbols = config.get(CONF_SYMBOLS)
timeseries = TimeSeries(key=api_key)
dev = []
for symbol in symbols:
try:
timeseries.get_intraday(symbol)
except ValueError:
_LOGGER.error(
"API Key is not valid or symbol '%s' not known", symbol)
return
dev.append(AlphaVantageSensor(timeseries, symbol))
add_devices(dev, True)
df["cum_roll_max"] = df["cum_return"].cummax()
df["drawdown"] = df["cum_roll_max"] - df["cum_return"]
df["drawdown_pct"] = df["drawdown"] / df["cum_roll_max"]
max_dd = df["drawdown_pct"].max()
return max_dd
# Download historical data for DJI constituent stocks
tickers = [
"MSFT", "AAPL", "FB", "AMZN", "INTC", "CSCO", "VZ", "IBM", "QCOM", "LYFT"
]
ohlc_intraday = {} # directory with ohlc value for each stock
key_path = "D:\\Udemy\\Quantitative Investing Using Python\\1_Getting Data\\AlphaVantage\\key.txt"
ts = TimeSeries(key='GAVN79RJETRO047U', output_format='pandas')
attempt = 0 # initializing passthrough variable
drop = [
] # initializing list to store tickers whose close price was successfully extracted
while len(tickers) != 0 and attempt <= 5:
tickers = [j for j in tickers if j not in drop]
for i in range(len(tickers)):
try:
ohlc_intraday[tickers[i]] = ts.get_intraday(symbol=tickers[i],
interval='5min',
outputsize='full')[0]
ohlc_intraday[tickers[i]].columns = [
"Open", "High", "Low", "Adj Close", "Volume"
]
drop.append(tickers[i])
# input file (relative path)
input_file = 'companies.csv'
# output file (relative path)
output_dir = 'stock_data'
output_file = output_dir + '/' + 'stock_' + str(start) + '_' + str(
end) + '.csv'
##############
#### CODE ####
# create output dir
os.makedirs(output_dir, exist_ok=True)
# load api key
ts = TimeSeries(key=api_key.KEY, output_format='pandas')
# create output file with header
with open(output_file, 'w') as f:
f.write('Date,Open,High,Low,Close,Volume,Company\n')
# process google
with open(input_file, 'r') as comp:
reader = csv.reader(comp)
# for each company
for row in reader:
name = str(row[0])
ticker = str(row[1]).strip()
print('\n' + name)
def main():
"""
Gamestonk Terminal is an awesome stock market terminal that has been developed for fun,
while I saw my GME shares tanking. But hey, I like the stock.
"""
# Enable VT100 Escape Sequence for WINDOWS 10 Ver. 1607
if sys.platform == "win32":
os.system("")
s_ticker = ""
s_start = ""
df_stock = pd.DataFrame()
s_interval = "1440min"
# Set stock by default to speed up testing
# s_ticker = "BB"
# ts = TimeSeries(key=cfg.API_KEY_ALPHAVANTAGE, output_format='pandas')
# df_stock, d_stock_metadata = ts.get_daily_adjusted(symbol=s_ticker, outputsize='full')
# df_stock.sort_index(ascending=True, inplace=True)
# s_start = datetime.strptime("2020-06-04", "%Y-%m-%d")
# df_stock = df_stock[s_start:]
# Add list of arguments that the main parser accepts
menu_parser = argparse.ArgumentParser(add_help=False, prog="gamestonk_terminal")
choices = [
"help",
"quit",
"q",
"clear",
"load",
"candle",
"view",
"export",
"disc",
"mill",
"ba",
"res",
"fa",
"ta",
"dd",
"eda",
"pred",
"ca",
"op",
"fred",
"pa",
"crypto",
"ra",
]
menu_parser.add_argument("opt", choices=choices)
completer = NestedCompleter.from_nested_dict({c: None for c in choices})
# Print first welcome message and help
print("\nWelcome to Gamestonk Terminal 🚀\n")
should_print_help = True
parsed_stdin = False
if gtff.ENABLE_THOUGHTS_DAY:
print("-------------------")
try:
thought.get_thought_of_the_day()
except Exception as e:
print(e)
print("")
# Loop forever and ever
while True:
main_cmd = False
if should_print_help:
print_help(s_ticker, s_start, s_interval, b_is_stock_market_open())
should_print_help = False
# Get input command from stdin or user
if not parsed_stdin and len(sys.argv) > 1:
as_input = " ".join(sys.argv[1:])
parsed_stdin = True
print(f"{get_flair()}> {as_input}")
elif session and gtff.USE_PROMPT_TOOLKIT:
as_input = session.prompt(f"{get_flair()}> ", completer=completer)
else:
as_input = input(f"{get_flair()}> ")
# Is command empty
if not as_input:
print("")
continue
# Parse main command of the list of possible commands
try:
(ns_known_args, l_args) = menu_parser.parse_known_args(as_input.split())
except SystemExit:
print("The command selected doesn't exist\n")
continue
b_quit = False
if ns_known_args.opt == "help":
should_print_help = True
elif (ns_known_args.opt == "quit") or (ns_known_args.opt == "q"):
break
elif ns_known_args.opt == "clear":
s_ticker, s_start, s_interval, df_stock = clear(
l_args, s_ticker, s_start, s_interval, df_stock
)
main_cmd = True
elif ns_known_args.opt == "load":
s_ticker, s_start, s_interval, df_stock = load(
l_args, s_ticker, s_start, s_interval, df_stock
)
main_cmd = True
elif ns_known_args.opt == "candle":
if s_ticker:
candle(
s_ticker,
(datetime.now() - timedelta(days=180)).strftime("%Y-%m-%d"),
)
else:
print(
"No ticker selected. Use 'load ticker' to load the ticker you want to look at.",
"\n",
)
main_cmd = True
elif ns_known_args.opt == "view":
if s_ticker:
view(l_args, s_ticker, s_start, s_interval, df_stock)
else:
print(
"No ticker selected. Use 'load ticker' to load the ticker you want to look at."
)
main_cmd = True
elif ns_known_args.opt == "export":
export(l_args, df_stock)
main_cmd = True
elif ns_known_args.opt == "disc":
b_quit = disc_controller.menu()
elif ns_known_args.opt == "mill":
b_quit = mill.papermill_menu()
elif ns_known_args.opt == "ba":
b_quit = ba_controller.menu(s_ticker, s_start)
elif ns_known_args.opt == "res":
b_quit = rm.res_menu(s_ticker, s_start, s_interval)
elif ns_known_args.opt == "ca":
b_quit = ca_controller.menu(df_stock, s_ticker, s_start, s_interval)
elif ns_known_args.opt == "fa":
b_quit = fam.fa_menu(s_ticker, s_start, s_interval)
elif ns_known_args.opt == "ta":
b_quit = ta_controller.menu(df_stock, s_ticker, s_start, s_interval)
elif ns_known_args.opt == "dd":
b_quit = ddm.dd_menu(df_stock, s_ticker, s_start, s_interval)
elif ns_known_args.opt == "eda":
if s_interval == "1440min":
b_quit = eda_controller.menu(df_stock, s_ticker, s_start, s_interval)
else:
df_stock = yf.download(s_ticker, start=s_start, progress=False)
df_stock = df_stock.rename(
columns={
"Open": "1. open",
"High": "2. high",
"Low": "3. low",
"Close": "4. close",
"Adj Close": "5. adjusted close",
"Volume": "6. volume",
}
)
df_stock.index.name = "date"
s_interval = "1440min"
b_quit = eda_controller.menu(df_stock, s_ticker, s_start, s_interval)
elif ns_known_args.opt == "op":
b_quit = op_controller.menu(s_ticker)
elif ns_known_args.opt == "fred":
b_quit = fm.fred_menu()
elif ns_known_args.opt == "pa":
b_quit = port_controller.menu()
elif ns_known_args.opt == "crypto":
b_quit = crypto_controller.menu()
elif ns_known_args.opt == "pred":
if not gtff.ENABLE_PREDICT:
print("Predict is not enabled in feature_flags.py")
print("Prediction menu is disabled")
print("")
continue
try:
# pylint: disable=import-outside-toplevel
from gamestonk_terminal.prediction_techniques import pred_menu as pm
except ModuleNotFoundError as e:
print("One of the optional packages seems to be missing")
print("Optional packages need to be installed")
print(e)
print("")
continue
except Exception as e:
print(e)
print("")
continue
if s_interval == "1440min":
b_quit = pm.pred_menu(df_stock, s_ticker, s_start, s_interval)
# If stock data is intradaily, we need to get data again as prediction
# techniques work on daily adjusted data. By default we load data from
# Alpha Vantage because the historical data loaded gives a larger
# dataset than the one provided by quandl
else:
try:
ts = TimeSeries(
key=cfg.API_KEY_ALPHAVANTAGE, output_format="pandas"
)
# pylint: disable=unbalanced-tuple-unpacking
df_stock_pred, _ = ts.get_daily_adjusted(
symbol=s_ticker, outputsize="full"
)
# pylint: disable=no-member
df_stock_pred = df_stock_pred.sort_index(ascending=True)
df_stock_pred = df_stock_pred[s_start:]
b_quit = pm.pred_menu(
df_stock_pred, s_ticker, s_start, s_interval="1440min"
)
except Exception as e:
print(e)
print("Either the ticker or the API_KEY are invalids. Try again!")
return
elif ns_known_args.opt == "ra":
b_quit = ra_controller.menu(df_stock, s_ticker, s_start, s_interval)
else:
print("Shouldn't see this command!")
continue
if b_quit:
break
else:
if not main_cmd:
should_print_help = True
print(
"Hope you enjoyed the terminal. Remember that stonks only go up. Diamond hands.\n"
)
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import sklearn.linear_model
import scipy.stats as stats
import pandas_market_calendars as mcal
from alpha_vantage.timeseries import TimeSeries
api_key = '8FIYTT49ZEZT2GV5'
ts = TimeSeries(key=api_key, output_format='pandas')
data, meta_data = ts.get_daily(symbol='SPY', outputsize='full')
data = data.reset_index()
data['date'] = data['date'].dt.strftime('%Y%m%d')
data['date'] = data['date'].values.astype(int)
X = np.c_[data['date']]
Y = np.c_[data['4. close']]
X = [i[0] for i in X]
Y = [i[0] for i in Y]
X = X[::-1] #REVERSING ORDER
Y = Y[::-1] #REVERSING ORDER
last_day = len(X) - 1
th_day = list(range(0, last_day + 1))
def YYYY_MM_DD_to_th_day(YMD):
early = nyse.schedule(start_date='1999-11-01', end_date=YMD)
return len(early) - 1
import pandas as pd
from alpha_vantage.timeseries import TimeSeries
import time
api_key = 'R7SX528FT8JX6F7O'
ts = TimeSeries(key =api_key, output_format = 'pandas')
data, meta_data = ts.get_intraday(symbol = 'MSFT', interval = '1min', outputsize = 'full')
data.
print(data)
i = 1
while i ==1 :
data.to_excel("stock_quote.xlsx")
time.sleep(60)
def update_metrics(n):
lon, lat, alt = satellite.get_lonlatalt(datetime.datetime.now())
ts = TimeSeries(key=api_key, output_format='pandas')
ti = TechIndicators(key=api_key, output_format='pandas')
period = 100
GOOGLdata_ts, GOOGLmeta_data_ts = ts.get_intraday(symbol='EBAY', interval='5min', outputsize='compact')
GOOGLdata_ti, GOOGLmeta_data_ti = ti.get_sma(symbol='EBAY', interval='5min', time_period=period, series_type='close')
def prepareData(series, lag_start, lag_end, test_size, target_encoding=False):
"""
series: pd.DataFrame
dataframe with timeseries
lag_start: int
initial step back in time to slice target variable
example - lag_start = 1 means that the model
will see yesterday's values to predict today
lag_end: int
final step back in time to slice target variable
example - lag_end = 4 means that the model
will see up to 4 days back in time to predict today
test_size: float
size of the test dataset after train/test split as percentage of dataset
target_encoding: boolean
if True - add target averages to the dataset
"""
# copy of the initial dataset
data = pd.DataFrame(series.copy())
data.columns = ["y"]
# lags of series
for i in range(lag_start, lag_end):
data["lag_{}".format(i)] = data.y.shift(-i)
# datetime features
# train-test split
y = data.dropna().y
X = data.dropna().drop(['y'], axis=1)
return X, y
X, y = prepareData(GOOGLdata_ts['4. close'], lag_start=0, lag_end=19, test_size=0.3, target_encoding=True)
X_train_scaled = scaler.fit_transform(X)
X_test_scaled = scaler.transform(X)
pred = model.predict(X_test_scaled)
closep = GOOGLdata_ts.iloc[0]['4. close']
smav = GOOGLdata_ti.iloc[0]['SMA']
predikt = pred[0]
if smav > predikt:
ton = 'Trading stategy: Bear Strategy'
else:
ton = 'Trading stategy: Bull Strategy'
style = {'padding': '5px', 'fontSize': '16px'}
return [
html.Span('Close Price Prediction: {0:.2f}'.format(predikt), style=style),
html.Span('SMA: {0:.2f}'.format(smav), style=style),
html.Span(ton.format(alt), style=style)
]
def grabData(key, input_ticker, delta):
tS = TimeSeries(key=key, output_format='pandas', indexing_type='date')
tI = TechIndicators(key=key, output_format='pandas')
data, meta_data = tS.get_daily_adjusted(
symbol=input_ticker,
outputsize='full') #compact for last 100 or full for everything
macd, macd_meta = tI.get_macd(symbol=input_ticker,
interval='daily',
series_type='close')
rsi, rsi_meta = tI.get_rsi(symbol=input_ticker,
interval='daily',
time_period=14,
series_type='close')
willr, willr_meta = tI.get_willr(symbol=input_ticker,
interval='daily',
time_period=14)
adx, adx_meta = tI.get_adx(symbol=input_ticker,
interval='daily',
time_period=14)
mom, mom_meta = tI.get_mom(symbol=input_ticker,
interval='daily',
time_period=10,
series_type='close')
all_vals = [data, macd, rsi, willr, adx, mom]
final_df = pd.concat(
all_vals, axis=1, sort=True
) # Sort arg may need to be False, leaving it blank raises Pandas error
final_df = final_df.dropna()
df = final_df.iloc[::-1]
df = df.reset_index()
df = df.drop(['6. volume', '7. dividend amount'], axis=1)
# *************************************************************************
labels = []
priceDiffernces = []
for index, row in df.iterrows():
if 0 <= index < delta:
pass
else:
initPrice = row[5]
deltaPrice = df.iloc[index - delta][5]
priceDiffernces.append(round((deltaPrice - initPrice), 2))
if deltaPrice > initPrice:
labels.append(1)
else:
labels.append(0)
df = df.drop(list(range(delta)))
labelsPD = pd.Series(labels)
priceDiffsPD = pd.Series(priceDiffernces)
df['Labels'] = labelsPD.values
df['Price Diffs'] = priceDiffsPD.values
df.to_csv(input_ticker + '.csv')
def get_alphavantage_compact_data(symbol=None):
if symbol is None:
symbol = 'MSFT'
ts = TimeSeries(output_format='pandas', indexing_type='date')
return ts.get_daily_adjusted(symbol=symbol, outputsize='compact')
df = DF.copy()
df["cum_return"] = (1 + df["ret"]).cumprod()
df["cum_roll_max"] = df["cum_return"].cummax()
df["drawdown"] = df["cum_roll_max"] - df["cum_return"]
df["drawdown_pct"] = df["drawdown"]/df["cum_roll_max"]
max_dd = df["drawdown_pct"].max()
return max_dd
# Download historical data for DJI constituent stocks
tickers = ["MSFT","AAPL","FB","AMZN","INTC", "CSCO","VZ","IBM","QCOM","LYFT"]
ohlc_intraday = {} # directory with ohlc value for each stock
key_path = "D:\\Udemy\\Quantitative Investing Using Python\\1_Getting Data\\AlphaVantage\\key.txt"
ts = TimeSeries(key=open(key_path,'r').read(), output_format='pandas')
attempt = 0 # initializing passthrough variable
drop = [] # initializing list to store tickerList whose close price was successfully extracted
while len(tickers) != 0 and attempt <=5:
tickers = [j for j in tickers if j not in drop]
for i in range(len(tickers)):
try:
ohlc_intraday[tickers[i]] = ts.get_intraday(symbol=tickers[i],interval='5min', outputsize='full')[0]
ohlc_intraday[tickers[i]].columns = ["Open","High","Low","Adj Close","Volume"]
drop.append(tickers[i])
except:
print(tickers[i]," :failed to fetch data...retrying")
continue
attempt+=1
def fetch_graph_results(strategy_name, investment_per_strategy, stock_symbol_array):
stock_details = []
five_days_history = []
investment_per_company = investment_per_strategy / 3
for stock_symbol in stock_symbol_array:
ts = TimeSeries(key='L7LPZFOTDXED8KS0')
data, meta_data = ts.get_daily_adjusted(stock_symbol)
if meta_data:
count = 0
for each_entry in data:
if count < 5:
stock_details.append(
[strategy_name, stock_symbol, each_entry, data[each_entry]['5. adjusted close']])
five_days_history.append(each_entry)
count = count + 1
else:
break
first_day = []
first_day_history = []
second_day_history = []
third_day_history = []
fourth_day_history = []
fifth_day_history = []
first_day_investment = 0
second_day_investment = 0
third_day_investment = 0
forth_day_investment = 0
fifth_day_investment = 0
graph_results = []
graph_results_detailed = []
for entry in stock_details:
if entry[2] == sorted(set(five_days_history))[0]:
first_day.append([entry[1], entry[3]])
no_of_stocks_per_company = math.floor(investment_per_company / float(entry[3]))
first_day_history.append([entry[1], round(float(entry[3]), 2), no_of_stocks_per_company])
first_day_investment += no_of_stocks_per_company * float(entry[3])
graph_results.append([sorted(set(five_days_history))[0], round(first_day_investment, 2)])
for entry in stock_details:
if entry[2] == sorted(set(five_days_history))[1]:
for company in first_day_history:
if company[0] == entry[1]:
second_day_history.append([entry[1], round(float(entry[3]), 2), company[2]])
second_day_investment += (float(entry[3]) * company[2])
elif entry[2] == sorted(set(five_days_history))[2]:
for company in first_day_history:
if company[0] == entry[1]:
third_day_history.append([entry[1], round(float(entry[3]), 2), company[2]])
third_day_investment += (float(entry[3]) * company[2])
elif entry[2] == sorted(set(five_days_history))[3]:
for company in first_day_history:
if company[0] == entry[1]:
fourth_day_history.append([entry[1], round(float(entry[3]), 2), company[2]])
forth_day_investment += (float(entry[3]) * company[2])
elif entry[2] == sorted(set(five_days_history))[4]:
for company in first_day_history:
if company[0] == entry[1]:
fifth_day_history.append([entry[1], round(float(entry[3]), 2), company[2]])
fifth_day_investment += (float(entry[3]) * company[2])
graph_results.append([sorted(set(five_days_history))[1], round(second_day_investment, 2)])
graph_results.append([sorted(set(five_days_history))[2], round(third_day_investment, 2)])
graph_results.append([sorted(set(five_days_history))[3], round(forth_day_investment, 2)])
graph_results.append([sorted(set(five_days_history))[4], round(fifth_day_investment, 2)])
graph_results_detailed.append([sorted(set(five_days_history))[0], first_day_history])
graph_results_detailed.append([sorted(set(five_days_history))[1], second_day_history])
graph_results_detailed.append([sorted(set(five_days_history))[2], third_day_history])
graph_results_detailed.append([sorted(set(five_days_history))[3], fourth_day_history])
graph_results_detailed.append([sorted(set(five_days_history))[4], fifth_day_history])
return graph_results, graph_results_detailed
# In[273]:
import pandas as pd
from alpha_vantage.timeseries import TimeSeries
import os
import pprint
import datetime as dt
from sklearn.preprocessing import StandardScaler
# In[15]:
ts = TimeSeries(key='AIH485OT2P8QGKIX', output_format='pandas')
# In[22]:
df = pd.read_csv('fund_comp.csv', header=0).set_index('company_id')
df1 = pd.read_csv('fund_by_comp.csv', header=0).set_index('company_id')
# In[17]:
#data from http://rankandfiled.com/#/data/hedgefunds
df2 = pd.read_csv('cik_ticker_map.csv', header=0,
delimiter='|').set_index('CIK')
# In[ ]:
df2 = pd.read_csv('cik_ticker_map.csv', header=0,
def get_alpha_key():
key_path = Path() / "key"
if key_path.exists():
with open(key_path, 'r') as f:
key = f.read()
return key
else:
raise FileExistsError(
"There is no file named 'key' in the project directory. Please add it with your Alpha Vantage API key."
)
KEY = get_alpha_key()
ts = TimeSeries(KEY, output_format='pandas')
ti = TechIndicators(KEY)
PATH_TO_SCRIPT_DIR = os.path.abspath(os.path.dirname(__file__))
PATH_TO_ROOT_DIR = os.path.normpath(os.path.join(PATH_TO_SCRIPT_DIR, '..'))
REQ_TYPES = [
"symbol", "last", "daily", "daily_adj", "intraday", "market_times"
]
INTERVALS = ["1min", "5min", "15min", "30min", "60min"]
def get_data(symbol,
mode="daily",
adjusted=False,
interval='15min',
import dash_core_components as dcc
import dash_html_components as html
from dash.dependencies import Output, Input
import dash_bootstrap_components as dbc
#in this section the User will type in the ticker they want displayed in the DASH application
# ATTENTION: Please enter your stock in the ticker string below
ticker = 'TSLA'
# Once ticker is entered, save the file and the dash app will automatically update
# In this section we make the API call and select which columns to pull data from. We'll use an interval of every 5 minutes
key = 'RLVN7TWQW8MB1ZI3'
ts = TimeSeries(key, output_format='pandas')
ttm_data, ttm_meta_data = ts.get_intraday(symbol=ticker,
interval='5min',
outputsize='compact')
df = ttm_data.copy()
df = df.transpose()
df.rename(index={
"1. open": "open",
"2. high": "high",
"3. low": "low",
"4. close": "close",
"5. volume": "volume"
},
inplace=True)
df = df.reset_index().rename(columns={'index': 'indicator'})
df = pd.melt(df, id_vars=['indicator'], var_name='date', value_name='rate')
def test_av_access(self):
ts = TimeSeries(config.AV_KEY, output_format="pandas")
ts.get_daily(symbol="MSFT", outputsize="compact")
ts.get_intraday(symbol="MSFT", interval="5min", outputsize="compact")
from alpha_vantage.timeseries import TimeSeries
import json
import sys
JSON_INDENT = 4
print(type(sys.argv[1]))
print(type(sys.argv[2]))
ts = TimeSeries(key='H0WG63BW6PGFSYEB')
# Get json object with the intraday data and another with the call's metadata
data, meta_data = ts.get_intraday(sys.argv[1], interval=sys.argv[2])
dic = {}
for i, j in data.items():
dic[i] = {}
for x, y in j.items():
dic[i][x.split(".")[1].strip()] = y
data = dic
#print(data)
with open("minute.json", 'w', encoding='utf-8') as output_file:
output_file.write(
str(
json.dumps(
data,
indent=JSON_INDENT,
# Commented out because str is python3 and accounts for encoding specifications
# ensure_ascii=False,
# encoding='utf-8'
)))
def get_vantage_client():
VANTAGE_API_KEY = 'R4RZ079WZET1M0JB'
return TimeSeries(key=VANTAGE_API_KEY, output_format='pandas')
def update_graph_live(n):
satellite = Orbital('TERRA')
ts = TimeSeries(key=api_key, output_format='pandas')
ti = TechIndicators(key=api_key, output_format='pandas')
period = 100
GOOGLdata_ts, GOOGLmeta_data_ts = ts.get_intraday(symbol='EBAY', interval='5min', outputsize='compact')
GOOGLdata_ti, GOOGLmeta_data_ti = ti.get_sma(symbol='EBAY', interval='5min', time_period=period, series_type='close')
data = {
'time': [],
'close price': [],
'SMA(simple moving average)': [],
'ML prediction of close price': []
}
def prepareData(series, lag_start, lag_end, test_size, target_encoding=False):
"""
series: pd.DataFrame
dataframe with timeseries
lag_start: int
initial step back in time to slice target variable
example - lag_start = 1 means that the model
will see yesterday's values to predict today
lag_end: int
final step back in time to slice target variable
example - lag_end = 4 means that the model
will see up to 4 days back in time to predict today
test_size: float
size of the test dataset after train/test split as percentage of dataset
target_encoding: boolean
if True - add target averages to the dataset
"""
# copy of the initial dataset
data = pd.DataFrame(series.copy())
data.columns = ["y"]
# lags of series
for i in range(lag_start, lag_end):
data["lag_{}".format(i)] = data.y.shift(-i)
# datetime features
# train-test split
y = data.dropna().y
X = data.dropna().drop(['y'], axis=1)
return X, y
X, y = prepareData(GOOGLdata_ts['4. close'], lag_start=0, lag_end=19, test_size=0.3, target_encoding=True)
X_train_scaled = scaler.fit_transform(X)
X_test_scaled = scaler.transform(X)
pred = model.predict(X_test_scaled)
for j in range(70):
tme = GOOGLdata_ts.index[j]
data['time'].append(tme)
cp = GOOGLdata_ts.iloc[j]['4. close']
data['close price'].append(cp)
predplot = pred[j] + 0.1
data['ML prediction of close price'].append(predplot)
sma = GOOGLdata_ti.iloc[j]['SMA']
data['SMA(simple moving average)'].append(sma)
print(data)
# Create the graph with subplots
fig = plotly.tools.make_subplots(rows=2, cols=1, vertical_spacing=0.2)
fig['layout']['margin'] = {
'l': 30, 'r': 10, 'b': 30, 't': 10
}
fig['layout']['legend'] = {'x': 0, 'y': 1, 'xanchor': 'left'}
fig.append_trace({
'x': data['time'],
'y': data['SMA(simple moving average)'],
'name': 'SMA',
'mode': 'lines+markers',
'type': 'scatter'
}, 1, 1)
fig.append_trace({
'x': data['time'],
'y': data['ML prediction of close price'],
'name': 'Prediction',
'mode': 'lines+markers',
'type': 'scatter'
}, 1, 1)
'''fig.append_trace({
'x': data['time'],
'y': data['Latitude'],
'text': data['time'],
'name': 'Longitude vs Latitude',
'mode': 'lines+markers',
'type': 'scatter'
}, 2, 1)'''
return fig
def results():
# build a request object
req = request.get_json(force=True)
print('input request', req)
# fetch action from json
action = req.get('queryResult').get('action')
#print('action',action)
if action == 'read_excel':
parameters = req['queryResult']['parameters']
print('action', action)
print('parameters', parameters)
exl = pd.read_excel('Portfolio.xlsx')
fname = parameters['given-name']
lname = parameters['last-name']
folio = parameters['number']
exl['Name'] = exl['Name'].astype('category')
exl = exl[(exl['Name'].str.contains(fname, case=False))
& (exl['Folio No'] == int(folio))]
filtered_exl = exl[[
'Companies', 'Stocks', 'Purchase Date', 'Purchase Price(USD)',
'Purchase Investment (USD)'
]]
total_investment = filtered_exl['Purchase Investment (USD)'].sum()
filtered_exl_dict = filtered_exl.to_dict(orient='records')
#print(filtered_exl_dict)
#print(type(filtered_exl_dict))
filtered_exl_dict.append(
{'Total Purchase Investments (USD)': round(total_investment, 2)})
print(filtered_exl_dict)
# return a fulfillment response
if len(filtered_exl) != 0:
return {'Here, are your details': filtered_exl_dict}
else:
return {
'fulfillmentText':
'User Authetication Error.We are not able to authenticate your details. Please enter correct Name & Folio Number. Thanks.'
}
elif action == 'marketvalueaction':
parameters = req['queryResult']['parameters']
print('action', action)
print('parameters', parameters)
apikey = 'JL9GIGT0KVN581XQ'
invst = pd.read_excel('Portfolio.xlsx')
ts1 = TimeSeries(key=apikey,
output_format='pandas',
indexing_type='integer')
fname = parameters['given-name']
currentvalue = parameters['currentmarketvalue'].lower()
folio = parameters['number']
if (
(currentvalue == 'current market value')
): #or (currentvalue == 'sure') or (currentvalue == 'ok') or (currentvalue == 'okay')) :
invst['Name'] = invst['Name'].astype('category')
invst = invst[(invst['Name'].str.contains(fname, case=False))
& (invst['Folio No'] == int(folio))]
tckr = invst['Ticker'].tolist()
start = time.time()
data, meta_data = ts1.get_batch_stock_quotes(symbols=tckr)
data.rename({'2. price': 'Current Market Price (USD)'},
axis=1,
inplace=True)
data.rename({'1. symbol': 'Ticker'}, axis=1, inplace=True)
data.rename({'4. timestamp': 'Current Date'}, axis=1, inplace=True)
current = pd.merge(invst, data, on='Ticker',
how='inner').drop(['date', '3. volume'], axis=1)
current['Current Market Price (USD)'] = current[
'Current Market Price (USD)'].astype('float')
current['Current Investment (USD)'] = current[
'Current Market Price (USD)'] * current['Stocks']
filtered_current = current[[
'Companies', 'Stocks', 'Purchase Price(USD)',
'Purchase Investment (USD)', 'Current Market Price (USD)',
'Current Investment (USD)'
]]
current_total = filtered_current['Current Investment (USD)'].sum()
filtered_current_dict = filtered_current.to_dict(orient='records')
filtered_current_dict.append({
'Current Market Value of All Investments (USD)':
round(current_total, 2)
})
print(filtered_current_dict)
end = time.time()
print('API time ', end - start)
# return a fulfillment response
if len(filtered_current) != 0:
return {'Here, are your details': filtered_current_dict}
else:
return {
'fulfillmentText':
'Please enter whether you would like to see current market value of your investments or not.Thanks.'
}
elif ((currentvalue == 'no') or (currentvalue == 'nope')
or (currentvalue == 'not')):
return {'fulfillmentText': 'Alright.'}
elif action == 'performeractions':
parameters = req['queryResult']['parameters']
print('action', action)
print('parameters', parameters)
apikey = 'K9HSCD76XIMHD8VJ'
invst = pd.read_excel('Portfolio.xlsx')
ts1 = TimeSeries(key=apikey,
output_format='pandas',
indexing_type='integer')
fname = parameters['given-name']
performer = parameters['performerentity'].lower()
folio = parameters['number']
invst['Name'] = invst['Name'].astype('category')
invst = invst[(invst['Name'].str.contains(fname, case=False))
& (invst['Folio No'] == int(folio))]
tckr = invst['Ticker'].tolist()
start = time.time()
data, meta_data = ts1.get_batch_stock_quotes(symbols=tckr)
data.rename({'2. price': 'Current Market Price (USD)'},
axis=1,
inplace=True)
data.rename({'1. symbol': 'Ticker'}, axis=1, inplace=True)
data.rename({'4. timestamp': 'Current Date'}, axis=1, inplace=True)
current = pd.merge(invst, data, on='Ticker',
how='inner').drop(['date', '3. volume'], axis=1)
current['Current Market Price (USD)'] = current[
'Current Market Price (USD)'].astype('float')
current['Current Investment (USD)'] = current[
'Current Market Price (USD)'] * current['Stocks']
filtered_current = current[[
'Companies', 'Stocks', 'Purchase Price(USD)',
'Purchase Investment (USD)', 'Current Market Price (USD)',
'Current Investment (USD)'
]]
current_total = filtered_current['Current Investment (USD)'].sum()
filtered_current['Stock Profit/Loss (USD)'] = filtered_current[
'Current Investment (USD)'] - filtered_current[
'Purchase Investment (USD)']
filtered_current['Stock Profit/Loss (USD)'] = round(
filtered_current['Stock Profit/Loss (USD)'], 2)
best = filtered_current[
filtered_current['Stock Profit/Loss (USD)'] ==
filtered_current['Stock Profit/Loss (USD)'].max()]
worst = filtered_current[
filtered_current['Stock Profit/Loss (USD)'] ==
filtered_current['Stock Profit/Loss (USD)'].min()]
end = time.time()
print('API time ', end - start)
if performer == 'good':
best = best[['Companies', 'Stocks', 'Stock Profit/Loss (USD)']]
filtered_current_dict = best.to_dict(orient='records')
print(filtered_current_dict)
return {
'Here is your best performing stock': filtered_current_dict
}
elif performer == 'bad':
worst = worst[['Companies', 'Stocks', 'Stock Profit/Loss (USD)']]
filtered_current_dict = worst.to_dict(orient='records')
print(filtered_current_dict)
return {
'Here is your worst performing stock': filtered_current_dict
}
#print(filtered_current_dict)
#print(type(filtered_current_dict))
#filtered_current_dict.append({'Current Market Value of All Investments (USD)':round(current_total,2)})
else:
return {
'fulfillmentText':
'Please provide input for either a best or worst performing stock.Thanks.'
}
elif action == 'goodbyeaction':
parameters = req['queryResult']['parameters']
print('action', action)
print('parameters', parameters)
goodbye = parameters['goodbyeentity'].lower()
if (
(goodbye == 'yes')
): #or (currentvalue == 'sure') or (currentvalue == 'ok') or (currentvalue == 'okay')) :
return {
'fulfillmentText':
'Alright sure, I can help you with your investment history, current market value of your investments or your best/worst performing stocks.'
}
elif ((goodbye == 'no'
)): #or (currentvalue == 'nope') or (currentvalue == 'not')):
return {
'fulfillmentText':
'Thanks for using Portfolio Bot.Have a good day!.'
}
else:
return {'fulfillmentText': 'Sorry,i am not able to understand this.'}
def get_daily(stock):
ts = TimeSeries(key=APIkey, output_format='pandas')
data, meta_data = ts.get_daily(symbol=stock, outputsize='full')
return data, meta_data
def __init__(self):
self.ts = TimeSeries('P9HHDBDFZ3RZYTSW', output_format='pandas')
self.stockDict = {'GOOGL':'Google', 'MSFT':'Microsoft','AAPL':'Apple','FB':'Facebook','TWTR':'Twitter'}
from alpha_vantage.timeseries import TimeSeries
import os
# API KEY---------------------------------------------------------
key = "LOK9IWR45QLHXH88"
ts = TimeSeries(key)
#---------------------------------------------------------
# Handling Historical Input------------------------------------------
market = ["DJI", "MSFT"]
marketstart = '09:31:00'
marketstop = '16:00:00'
#USA eastern time by default (GMT -5), 9:30AM opens, 4PM closes, Weekend closes
#if historical is true, it will fetch ALL data past 20 years for every stock in the market
#---------------------------
historical = True
#---------------------------
if historical == True:
print("fetching historical data")
print("will fetch the following stocks: {}".format(str(market)))
for stocks in market:
data, meta_data = ts.get_daily_adjusted(stocks, outputsize='full')
f = open(
"{}\\Input_CSV\\Historical\\{}.txt".format(
os.path.dirname(__file__), str(stocks)), 'w')
for days in data:
currentday = data[days]
# Use this if viewer friendly text is needed
#currentline = "0. day: {}\t1. open: {}\t2. high: {}\t3. low: {}\t4. close: {}\t5. adjusted close: {}\t6. volume: {}\t7. dividend amount: {}\t8. split coefficient: {}\n"
import os
import stocktrends
import pandas as pd
from alpha_vantage.timeseries import TimeSeries
key = os.environ.get('ALPHAVANTAGE_KEY')
print(key)
ts = TimeSeries(key=key, output_format='pandas')
symbol = 'NSE:RELIANCE'
df, meta_data = ts.get_daily_adjusted(symbol=symbol, outputsize='compact')
renames = {
'1. open': 'open',
'2. high': 'high',
'3. low': 'low',
'4. close': 'close',
'5. adjusted close': 'adjusted close',
'6. volume': 'volume',
'7. dividend amount': 'dividend amount',
'8. split coefficient': 'split coefficient'
}
df.rename(columns=renames, inplace=True)
df.to_csv('tmp.csv')
df = pd.read_csv('tmp.csv')
renko = stocktrends.Renko(df)
renko.brick_size = 9.5
r = renko.get_bricks()
#print(stocks)
stocks = stocks.to_numpy()
row, column = stocks.shape
#current allowed loss and required profit
loss = np.array(stocks[1:row, 4])
buy = np.array(stocks[1:row, 2]) #price at which bought
profit = np.array(stocks[1:row, 3])
#array for current prices of the stocks
cur = np.array([])
#use alpha_vantage to find current price
api = 'ENTER_YOUR_API' #to get your API go to alphavantage website create a free account and copy paste the key between quotes
#example: api = 'ASDGWRIGVANVFBGB'
ts = TimeSeries(key=api, output_format='pandas')
i = 1
while i < row: #find current stock price of each stock in the list
print(str(stocks[i, 0]))
data, meta_data = ts.get_intraday(symbol=str(stocks[i, 0]),
interval='1min',
outputsize='full')
cur = np.append(cur, float(data.iat[0, 3]))
print(cur)
i = i + 1
time.sleep(
12) #to ensure 5 calls per minute as max calls are 5 on AlphaVantage
#compare current prices with max allowed loss
i = 0
class intradayCrawler(Crawler):
def __init__(self, config):
super().__init__(config)
self.config = config
self.interval_capabilities = ['1min', '5min', '15min', '30min', '60min']
self.default_interval = '5min'
# Check that we have an api key
if 'api_key' in self.config.keys():
init_api_key(self.config['api_key'])
else:
init_api_key()
# Verify that it works
verify_api_key()
# Check the configuration
if 'interval' not in self.config:
self.config['interval'] = '1min'
if self.config['interval'] not in self.interval_capabilities:
warnings.warn(f'An interval of {self.config["interval"]} is not supported. Using {self.default_interval}')
self.config['interval'] = self.default_interval
if 'symbol' not in self.config:
raise Exception('No symbol specified for the Crawler')
self.ts = TimeSeries(output_format='json')
self.base_url = config['base_url'] if 'base_url' in config else 'http://localhost:8080'
def __getitem__(self, index):
data, meta_data = self.ts.get_intraday(symbol= self.config['symbol'],
interval=self.config['interval'],
outputsize='full')
last_refreshed = time.mktime(datetime.strptime(meta_data['3.Last Refreshed'], "%Y-%m-%d %H:%M:%S").timetuple())
# Todo: check with date time from db and stop iteration?
dt_object = datetime.fromtimestamp(last_refreshed)
new_data = EconDataListRequest(self.compile_data(data))
return new_data
def post(self, data):
if data is None:
return
try:
response = req.post(url = self.base_url + '/api/alphavantage_crawler/insert', data=data.serialize())
if response.status_code != 200:
# bad request? 404? duplicates? -- only thing that matters is that it is not OK
# connectivity is not bad because exception was not raised, so no reschedule
# that should be a dev-only error. Thus, just notify discord
raise Exception(f'Got not-OK status code {response.status_code}.')
# success
except BaseException as e:
print(str(e))
notify('crawler', human_required_update(str(e), 'alphavantage'))
return
def __str__(self):
return "Alpha Vantage"
def datetime_to_timestamp(self, datetime):
return time.mktime(datetime.strptime(datetime, "%Y-%m-%d %H:%M:%S").timetuple())
def compile_data(self, data):
EconData_list = []
for timestamp_key, values in data.items():
EconData_list.append(
EconData(
timestamp= self.datetime_to_timestamp(timestamp_key),
equity= self.config['symbol'],
open_price= values['open'],
close_price= values['close'],
high_price= values['high'],
low_price= values['low'],
volume= values['volume'],
)
)
return EconData_list
import pandas as pd
import chart_studio.plotly as py
import plotly.graph_objs as go
import datetime
from alpha_vantage.timeseries import TimeSeries
# TS data acessor
ts = TimeSeries(key='Y9AHX32YU1JIRCEJ',output_format='pandas')
stock_code = 'SQ'
def read_stock(stock_code, interval = '5min'):
df, _ = ts.get_intraday(symbol= stock_code,
interval=interval,
outputsize='full')
# trim the df
df.rename(index= pd.to_datetime,columns = lambda x : x.split(' ')[-1],inplace = True)
return df
# 5-minutes interval
df_5min = read_stock(stock_code)
# 1-minute interval
df_1min = read_stock(stock_code, interval= '1min')
def dataimport():
###Main program of this python file that imports data from alphavantage,
###and exports a csv file with historical data of the listed stocks
#Import the list of DJIA companies during the 17year span
#This creates a matrix of dates on top, and then 30 companies in DJIA
djiacompanies = pd.read_csv(
'/Users/takuyawakayama/Desktop/Columbia/APMA4903 Seminar/djia-components.csv'
)
#Create list of dates that there was an index change
#type=DatetimeIndex, list of dates of form datetime64[ns]
switchdates = pd.to_datetime(list(djiacompanies))
#Lists all companies that we might ever use. type = LIST
allcompanies = pd.Series(djiacompanies.values.ravel()).unique().tolist()
#API key for Alphavantage
apikey = 'AU6S38KFU04HJB8S'
outputsize = 'full'
#Initialize dataframe using AAPL as sample company
ts = TimeSeries(key=apikey, output_format='pandas')
totaldatadf, meta_data = ts.get_daily_adjusted(symbol='AAPL',
outputsize=outputsize)
columns = [
'low', 'open', 'high', 'close', 'volume', 'split coefficient',
'dividend amount'
]
totaldatadf.drop(columns, inplace=True, axis=1)
totaldatadf = totaldatadf.rename(columns={'adjusted close': 'nan'})
#Create dataframe of historical daily prices for each company ever in DJIA
for company in allcompanies:
#Sometimes gives Error 503, so force program to complete
connected = False
while not connected:
try:
companydatadf, meta_data = ts.get_daily_adjusted(
symbol=company, outputsize=outputsize)
columns = [
'low', 'open', 'high', 'close', 'volume',
'split coefficient', 'dividend amount'
]
companydatadf.drop(columns, inplace=True, axis=1)
companydatadf = companydatadf.rename(
columns={'adjusted close': company})
totaldatadf = pd.concat([totaldatadf, companydatadf], axis=1)
connected = True
except:
time.sleep(10)
pass
#Delete sample column
totaldatadf.drop('nan', axis=1, inplace=True)
#Reorder
totaldatadf = totaldatadf.iloc[::-1]
#Export to CSV
totaldatadf.to_csv("totaldata.csv")
return
class OptimizePortfolio():
def __init__(self):
self.ts = TimeSeries('P9HHDBDFZ3RZYTSW', output_format='pandas')
self.stockDict = {'GOOGL':'Google', 'MSFT':'Microsoft','AAPL':'Apple','FB':'Facebook','TWTR':'Twitter'}
def loadCurrentPortfolio(self, accountDetails):
stocks = ['GOOGL','MSFT','TWTR','FB','AAPL']
# currentEvaluation = 0
# for s in stocks:
# price = self.getLiveStockRate(s)
# alloc = accountDetails[s][0]
# currentEvaluation += alloc * 10 * price
currentEvaluation = "Thank you! The current portfolio allocations are as follows:"
for s in stocks:
if accountDetails[s][0] > 0.0:
currentEvaluation += " " + str(accountDetails[s][0] * 100) + "% stocks of " + self.stockDict.get(s) + ","
currentEvaluation = currentEvaluation.strip(',')
return currentEvaluation
def getLiveStockRate(self, stockCode):
df = self.ts.get_intraday(stockCode, interval='1min', outputsize='compact')
df = df[0]['4. close']
return df[len(df)-1]
def getDailyStockRate(self, stockCode):
# df,_ = self.ts.get_daily(stockCode, outputsize='full')
df = pd.read_csv(os.getcwd() + "/Data/daily_"+stockCode+".csv", index_col='date')
df = df.rename(columns={'1. open': 'Open', '2. high':'High', '3. low':'Low', '4. close':'Close', '5. volume':'Volume'})
return df
def optimizePortfolio(self, accountNumber, loadPortfolioDataObject):
print(accountNumber)
accountDetails = loadPortfolioDataObject.getAccountDetails(accountNumber)
stocks = ['GOOGL','MSFT','TWTR','FB','AAPL']
stockAllocations = []
dfList = []
for s in stocks:
dfList.append(self.getDailyStockRate(s))
stockAllocations.append((s, accountDetails[s][0]))
companyAllocations = OrderedDict(stockAllocations)
startDate = '2019-01-01'
endDate = datetime.today().strftime('%Y-%m-%d')
dates = pd.date_range(startDate, endDate)
newdf = pd.DataFrame(index = dates)
for id, df in enumerate(dfList):
df.drop(['Open', 'High', 'Low', 'Volume'], axis=1, inplace=True)
df = df.rename(columns={'Close':stocks[id]})
newdf = newdf.join(df)
newdf = newdf.dropna()
afterdf = newdf
norm = newdf/newdf.iloc[0]
norm = norm.astype(float)
for s in stocks:
norm[s] = norm[s].astype(float)
norm[s] *= float(companyAllocations.get(s)*accountDetails['TOTAL'][0])
evaluation = norm.sum(axis=1)
before, beforeSharpeRatio, beforePortValue = self.printStats(evaluation)
baseAllocation = []
for _, value in companyAllocations.items():
baseAllocation.append(value)
baseAllocation = np.array(baseAllocation)
self.currentValue = accountDetails['TOTAL'][0]
alloc = minimize(self.calculateSharpeRatio, baseAllocation, args=(afterdf,),method='SLSQP',
bounds=((0,1),(0,1),(0,1),(0,1),(0,1)),constraints=({'type':'eq','fun':lambda inputs: 1.0-np.sum(inputs)}))
dates = pd.date_range(startDate, endDate)
newdf = pd.DataFrame(index = dates)
for id, df in enumerate(dfList):
df = df.rename(columns={'Close':stocks[id]})
newdf = newdf.join(df)
newdf = newdf.dropna()
norm = newdf/newdf.iloc[0]
norm = norm.astype(float)
for id, s in enumerate(stocks):
norm[s] = norm[s].astype(float)
norm[s] *= float(alloc.x[id]*accountDetails['TOTAL'][0])
evaluationNew = norm.sum(axis=1)
after, afterSharpeRatio, afterPortValue = self.printStats(evaluationNew)
s1 = "The current portfolio allocations are as follows:"
for s in stocks:
if accountDetails[s][0] > 0.0:
s1 += " " + str(accountDetails[s][0] * 100) + "% stocks of " + self.stockDict.get(s) + ","
s1 = s1.strip(',')
s1 += ". Based on these allocations, the current portfolio returns are as follows. " + before
s1 += ". However, on optimizing it, the new portfolio returns are as follows. " + after
s1 += ". These new returns can be achieved if portfolio allocations change to the following:"
for id,s in enumerate(stocks):
if alloc.x[id] > 0.0:
s1 += " " + str(alloc.x[id] * 100) + "% stocks of " + self.stockDict.get(s) + ","
s1 = s1.strip(',')
if afterPortValue > beforePortValue:
s1 += ". The optimized portfolio is $" + str(afterPortValue - beforePortValue) + " higher than original portfolio."
else:
s1 += ". The optimized portfolio is $" + str(beforePortValue - afterPortValue) + " less than original portfolio as original portfolio had higher risks and the optimization process tries to balance the risk involved."
s1 += " Kindly drop by our office, if you want to update your portfolio allocations. Kindly type quit to exit or type Hello to continue chatting with me."
return s1
def printStats(self, evaluation):
cumulativeReturn = (evaluation[-1]/evaluation[0])-1
dailyReturn = evaluation.copy()
dailyReturn[1:] = (evaluation[1:]/evaluation[:-1].values)-1
dailyReturn = dailyReturn[1:]
dailyReturnAverage = dailyReturn.mean()
dailyReturnStd = dailyReturn.std()
sharpeRatio = dailyReturnAverage/dailyReturnStd
sharpeRatio = np.sqrt(len(evaluation))*sharpeRatio
portValue = evaluation.iloc[len(evaluation)-1]
s1 = "Cumulative Return is $" + str(cumulativeReturn)
s1 = s1 + ". Daily Return mean is $" + str(dailyReturnAverage)
s1 = s1 + ". Volatility or Standard Deviation is " + str(dailyReturnStd)
s1 = s1 + ". Sharpe Ratio is " + str(sharpeRatio)
s1 = s1 + ". Portfolio evaluation at the end of the term is $" + str(portValue) + "."
return s1, sharpeRatio, portValue
def calculateSharpeRatio(self, allocs, afterdf):
norm = afterdf/afterdf.iloc[0]
allocated = norm * allocs
newValue = allocated * self.currentValue
evaluationNew = newValue.sum(axis=1)
dailyReturn = evaluationNew.copy()
dailyReturn[1:] = (evaluationNew[1:]/evaluationNew[:-1].values)-1
dailyReturn = dailyReturn[1:]
sharpeRatio = dailyReturn.mean()/dailyReturn.std()
sharpeRatio = np.sqrt(len(evaluationNew))*sharpeRatio
return -1*sharpeRatio
# to load needed modules
import quandl # financial data source
import pandas as pd # for dataframe setup and csv loading
from datetime import datetime # timse series: date convention
import matplotlib.pyplot as plt # module for plotting
import os # for input/output of files/directories
import plotly.offline as pyo
import plotly.graph_objs as go
from alpha_vantage.timeseries import TimeSeries
TICKER = 'EOD/AMZN' # use either EOD or XNAS(datasets) / then ticker
TICKER2 = TICKER[-4:] # change according to number of ticker characters
symbol = TICKER2
os.chdir(r'D:\Users\jong\PyProjects\Stocks\US Stocks')
key = open('alphavantage.txt', 'r').read()
ts = TimeSeries(key=key, output_format='pandas')
data = data, meta_data = ts.get_daily_adjusted(symbol=symbol,
outputsize='full')
data = data.reset_index()
data['date'] = pd.to_datetime(data['date'])
data.set_index('date', inplace=True)
print(data.tail())
x = data.index
dfA = data['4. close']
y1 = dfA
Product_A = [
go.Scatter(
x=x,
y=y1,
from alpha_vantage.timeseries import TimeSeries
import datetime,time
ts = TimeSeries(key='25JBS8HQYNAQ0EIU', output_format='pandas')
def get_stock_data_1min(symbol):
print(datetime.datetime.now())
data, meta_data = ts.get_intraday(symbol=symbol,interval='1min')
print(datetime.datetime.now())
print(data)
if __name__ == "__main__":
symbol="7974.T"
time.sleep(60*60*3)
i=0
while True:
now = datetime.datetime.now()
if now.second==0 or now.second==30 :
get_stock_data_1min(symbol)
time.sleep(2)
i += 1
time.sleep(0.9)
# print(i)
if i==100000:
break
User = '******'
PassWord = '******'
Host = '127.0.0.1'
Port = '3306'
Database = 'SEProject'
api_key = 'EQ6GGWD5D4ME4283'
# define database engines
sqlite_engine = create_engine('sqlite:///database_stock.db',
convert_unicode=True,
echo=True)
# MYSQL_engine = create_engine(
# 'mysql+mysqlconnector://' + User + ':' + PassWord +
# '@' + Host + ':' + Port + '/' + Database, echo=False)
# get TimeSeries/TechIndicator object of Alpha Vantage API
ts = TimeSeries(key=api_key, output_format='pandas', retries=20)
ti = TechIndicators(key=api_key, output_format='pandas', retries=20)
# using alpha vantage finance api to save data into a pandas dataframe
stocks = [
'AAPL', 'GOOGL', 'NVDA', 'AABA', 'AMZN', 'MSFT', 'BAC', 'NKE', 'NFLX', 'FB'
]
def init_db():
# initialize database and create schema if using mysql, if using sqlite it's not necessary
try:
cnx = mysql.connector.connect(
user=User, password=PassWord,
host=Host) # using configuration of sever
except mysql.connector.Error:
# https://github.com/RomelTorres/alpha_vantage
from alpha_vantage.timeseries import TimeSeries
from pprint import pprint
ts = TimeSeries(key='Y3086XYRBVO5KMFD', output_format='pandas')
data, meta_data = ts.get_intraday('AAPL', interval='1min', outputsize='full')
pprint(data.head(5))
from alpha_vantage.timeseries import TimeSeries from download_stock_av import api_key ts = TimeSeries(key=api_key.KEY, output_format='pandas') df, meta_data = ts.get_daily(symbol='VIG.VI', outputsize='compact') # print(data) print(df.loc[['2017-11-28']])
