def plot_stock_prices_interactive():
if request.method == 'GET':
return render_template('plot_prices_beta_1.html')
else:
app_plots.vars = {} # This is a dictionary
# Define the variables. This is a local variable, but in Flask it will be passed to the plot route I guess
if 'data' in request.form:
app_plots.vars['data_src'] = request.form['data']
# This get the data source
else:
return render_template(
'plot_prices_beta_1.html',
error_data=
'<font size="3" color="red" > Choose at least one data source </font>'
)
app_plots.vars['sym'] = request.form['sym'].upper().strip(';').split(
';') # 'sym' should be defined in html file as name
if (app_plots.vars['sym'][0] == ''): # sym is a list delimited by ;
return render_template(
'plot_prices_beta_1.html',
error_sym=
'<font size="3" color="red" > Provide at least one ticker symbol </font>'
)
#print request.form
if len(
request.form['start_date']
) != 0: # Here start and end date are keys are coming even if they are empty
try:
app_plots.vars['start_date'] = dt.datetime.strptime(
request.form['start_date'], '%m/%d/%Y')
except ValueError:
return render_template(
'plot_prices_beta_1.html',
error_start_date=
'<font size="3" color="red" > Wrong date format </font>')
else:
# Take 1 year ago of the current date
app_plots.vars['start_date'] = dt.datetime.today() - dt.timedelta(
days=365) # This does not give the accurate 5 years
if len(request.form['end_date']) != 0:
try:
app_plots.vars['end_date'] = dt.datetime.strptime(
request.form['end_date'], '%m/%d/%Y')
except ValueError:
return render_template(
'plot_prices_beta_1.html',
error_end_date=
'<font size="3" color="red" > Wrong date format </font>')
else:
# Take today as the default date
app_plots.vars['end_date'] = dt.datetime.today()
if 'bench_sym' in request.form:
app_plots.vars['bench_sym'] = request.form['bench_sym']
else:
app_plots.vars['bench_sym'] = 'SPY'
symbols = app_plots.vars['sym'] # Here symbol will be a list
# print request.form
# Add the benchmark symbol to the symbols
symbols.insert(0, app_plots.vars['bench_sym'])
# Insert the default symbol in the symbols list
#print symbols,usr_price_features, app_plots.vars['start_date'],app_plots.vars['end_date']
if app_plots.vars['data_src'] == 'get_data_quandl':
# Here get all the required features
features = ['Open', 'Close', 'High', 'Low', 'Volume', 'Adj. Close']
full_data = [(sym,
apicall_data.get_data_from_quandl(
symbol=sym,
features=features,
start_dt=app_plots.vars['start_date'],
end_dt=app_plots.vars['end_date']))
for sym in symbols]
script_ele, div_ele = plot_symbols_interactive(full_data, 'Quandl')
#computed_df=compute_params(full_data)
#script_param,div_param=plot_params(full_data)
return render_template('plot_prices_beta_1.html',
script_symbols=script_ele,
plot_div_symbols=div_ele)
elif app_plots.vars['data_src'] == 'get_data_yahoo':
# TODO: This needs a lot of change (pass not yet implemented)
# data_dict=apicall_data.get_data_from_yahoo(symbol=symbols, features=features)
return render_template(
'plot_prices_beta_1.html',
error_yahoo=
'<font size="3" color="red"> Data source not yet enabled </font>'
)
def getMLmodels():
if request.method == 'GET':
return render_template('ml_models.html')
else:
# check if the post request has the file part
app_mlModels.vars = {}
app_mlModels.vars['ml_algo'] = request.form['ml_algo']
bench_sym = 'SPY'
# This is not available for the user
if (request.form['sym'] == ''): # sym is a list delimited by ;
return render_template(
'ml_models.html',
error_sym=
'<font size="3" color="red" > Provide at least one ticker symbol </font>'
)
else:
app_mlModels.vars['sym'] = request.form['sym'].upper().strip(
';').split(';')
app_mlModels.vars['sym'].insert(0, 'SPY')
# SPY is the bench mark symbol which is not accessible to the user
if len(
request.form['start_date']
) != 0: # Here start and end date are keys are coming even if they are empty
try:
app_mlModels.vars['start_date'] = dt.datetime.strptime(
request.form['start_date'], '%m/%d/%Y')
except ValueError:
return render_template(
'ml_models.html',
error_start_date=
'<font size="3" color="red" > Wrong date format </font>')
else:
# Take 5 years ago of the current date
app_mlModels.vars['start_date'] = dt.datetime.today(
) - dt.timedelta(
days=5 * 365) # This does not give the accurate 5 years
if len(request.form['end_date']) != 0:
try:
app_mlModels.vars['end_date'] = dt.datetime.strptime(
request.form['end_date'], '%m/%d/%Y')
except ValueError:
return render_template(
'ml_models.html',
error_end_date=
'<font size="3" color="red" > Wrong date format </font>')
else:
# Take today as the default date
app_mlModels.vars['end_date'] = dt.datetime.today()
#app_mlModels.vars['window']=int(request.form['window']) # Default window size is set to 20
app_mlModels.vars['ml_algo'] = request.form['ml_algo']
app_mlModels.vars['bench_ml_algo'] = request.form['bench_ml_algo']
if app_mlModels.vars['ml_algo'] == app_mlModels.vars['bench_ml_algo']:
return render_template(
'ml_models.html',
error_same_mdl=
'<font size="3" color="red" > ML-algorithm and the Benchmark should be different </font>'
)
app_mlModels.vars['future_days'] = int(request.form['future_days'])
#print request.form
full_data = [(sym,
apicall_data.get_data_from_quandl(
symbol=sym,
features=['Adj. Close'],
start_dt=app_mlModels.vars['start_date'],
end_dt=app_mlModels.vars['end_date']))
for sym in app_mlModels.vars['sym']]
# Convert this to required format
prices_df = util.get_data(full_data)
# Drop the bench mark price
prices_df = prices_df.drop(bench_sym, axis=1)
split_number = 100
# This can be changed as needed, primarly use for spliting the data into train (train+cv) and test set
metrics_df, future_df, bench_future_df, pct_tab = computeFeatures(
prices_df, app_mlModels.vars['future_days'], split_number
) # Prices should technically have one symbol, but also possible that they might have multiple symbols
# print metrics_df
# Plot the time-series graph with past and future values
tab1 = plotPredicted(prices_df, future_df,
dict_algo_names_map[app_mlModels.vars['ml_algo']],
split_number)
tab2 = plotPredicted(
prices_df, bench_future_df,
dict_algo_names_map[app_mlModels.vars['bench_ml_algo']],
split_number)
tabs = Tabs(tabs=[tab1, tab2, pct_tab])
script_el_data, div_el_data = components(tabs)
# Put the metrics table in the html using bokeh
metrics_data = dict(metrics_df[[i
for i in metrics_df.columns]].round(4))
#print metrics_data
metrics_data[
'Metric'] = metrics_df.index # This will add the index (Note: Instead of Metric, if I use index, then the width of output index column cannot be adjustested )
source = ColumnDataSource(metrics_data)
columns = [TableColumn(field=i, title=i) for i in metrics_df.columns]
# Insert the index column to the list of columns
columns.insert(0, TableColumn(field="Metric", title="Metric"))
metrics_table = DataTable(source=source,
columns=columns,
height=250,
width=400)
script_metrics, div_metrics = components(WidgetBox(metrics_table))
# Similarly for the price describe data
price_describe = prices_df.describe().round(4)
price_describe_data = dict(price_describe[[i for i in price_describe]])
price_describe_data[
'Metric'] = price_describe.index # This will add the index (Note: Instead of Metric, if I use index, then the width of output index column cannot be adjustested )
source = ColumnDataSource(price_describe_data)
columns = [
TableColumn(field=i, title=i) for i in price_describe.columns
]
# Insert the index column to the list of columns
columns.insert(0, TableColumn(field="Metric", title="Metric"))
price_describe_table = DataTable(source=source,
columns=columns,
height=250,
width=400)
script_price_describe, div_price_describe = components(
WidgetBox(price_describe_table))
return render_template('ml_models.html',
script_el_data=script_el_data,
div_el_data=div_el_data,
script_metrics=script_metrics,
div_metrics=div_metrics,
script_price_describe=script_price_describe,
div_price_describe=div_price_describe)
def plot_stock_prices():
if request.method=='GET':
return render_template('plot_prices.html')
else:
app_quantfy.vars={} # This is a dictionary
# Define the variables. This is a local variable, but in Flask it will be passed to the plot route I guess
app_quantfy.vars['sym'] = request.form['sym'].upper().strip(';').split(';') # 'sym' should be defined in html file as name
if 'data' in request.form:
app_quantfy.vars['data_src']=request.form['data']; # This get the data source
else:
return render_template('plot_prices.html',error_data='<font size="3" color="red" > Choose at least one data source </font>')
#print request.form
if len(request.form['start_date'])!=0: # Here start and end date are keys are coming even if they are empty
try:
app_quantfy.vars['start_date']=dt.datetime.strptime(request.form['start_date'],'%m/%d/%Y')
except ValueError:
return render_template('plot_prices.html',error_start_date='<font size="3" color="red" > Wrong date format </font>')
else:
# Take 5 years ago of the current date
app_quantfy.vars['start_date']=dt.datetime.today()-dt.timedelta(days=5*365) # This does not give the accurate 5 years
if len(request.form['end_date'])!=0:
try:
app_quantfy.vars['end_date']=dt.datetime.strptime(request.form['end_date'],'%m/%d/%Y')
except ValueError:
return render_template('plot_prices.html',error_end_date='<font size="3" color="red" > Wrong date format </font>')
else:
# Take today as the default date
app_quantfy.vars['end_date']=dt.datetime.today()
app_quantfy.vars['price_features']=defaultdict(); # This is an empty dictionary
app_quantfy.vars['compute_features']=defaultdict(); # This is a dictionary for computing the requested features
if 'bench_sym' in request.form:
app_quantfy.vars['bench_sym']=request.form['bench_sym']
else:
app_quantfy.vars['bench_sym']='SPY'
if (app_quantfy.vars['sym'][0]=='') : # sym is a list delimited by ;
return render_template('plot_prices.html',error_sym='<font size="3" color="red" > Provide at least one ticker symbol </font>')
symbols=app_quantfy.vars['sym'] # Here symbol will be a list
# Add the benchmark symbol to the symbols
symbols.insert(0,app_quantfy.vars['bench_sym']); # Insert the default symbol in the symbols list
usr_price_features=list(app_quantfy.vars['price_features'].keys())
#print symbols,usr_price_features, app_quantfy.vars['start_date'],app_quantfy.vars['end_date']
if app_quantfy.vars['data_src']=='get_data_quandl':
# This is list of tuples, with first element in the tuple being symbol and second element being dict
# Here get the data for all the price features, filter it in the plot_symbols function, so all the price features are present here
features=['Open','Close','High','Low','Volume','Adj. Close']
full_data=[(sym, apicall_data.get_data_from_quandl(symbol=sym, features=features,start_dt=app_quantfy.vars['start_date'],end_dt=app_quantfy.vars['end_date'])
) for sym in symbols]
# Pass user selected price features to the plot function
#script_ele,div_ele=plot_symbols(full_data,usr_price_features, 'Quandl')
script_ele,div_ele=plot_symbols_interactive(full_data, 'Quandl')
computed_df,describe_df=compute_params(full_data)
# print describe_df
computed_df=computed_df.round(5)
script_computed_params,div_computed_params=convert_pd_bokeh_html(computed_df.round(4))
script_describe,div_describe=convert_pd_bokeh_html(describe_df.round(4))
script_param,div_param=plot_params(full_data)
return render_template('plot_prices.html',script_symbols=script_ele,plot_div_symbols=div_ele,
script_computed_params=script_computed_params,div_computed_params=div_computed_params,
script_params=script_param,plot_div_features=div_param,
script_describe=script_describe,div_describe=div_describe)
elif app_quantfy.vars['data_src']=='get_data_yahoo':
# TODO: This needs a lot of change (pass not yet implemented)
# data_dict=apicall_data.get_data_from_yahoo(symbol=symbols, features=features)
return render_template('plot_prices.html',error_yahoo='<font size="3" color="red"> Data source not yet enabled </font>')
def portfolio_page():
if request.method=='GET':
return render_template('portfolio.html')
else:
app_quantfy.vars={} # This is a dictionary
# Define the variables. This is a local variable, but in Flask it will be passed to the plot route I guess
app_quantfy.vars['sym'] = request.form['sym'].upper().strip(';').split(';') # 'sym' should be defined in html file as name
if (app_quantfy.vars['sym'][0]=='') : # sym is a list delimited by ;
return render_template('portfolio.html',error_sym='<font size="3" color="red" > Provide at least one ticker symbol </font>')
if len(request.form['start_date'])!=0: # Here start and end date are keys are coming even if they are empty
try:
app_quantfy.vars['start_date']=dt.datetime.strptime(request.form['start_date'],'%m/%d/%Y')
except ValueError:
return render_template('portfolio.html',error_start_date='<font size="3" color="red" > Wrong date format </font>')
else:
# Take 1 years ago of the current date
app_quantfy.vars['start_date']=dt.datetime.today()-dt.timedelta(days=365) # This does not give the accurate 5 years
if len(request.form['end_date'])!=0:
try:
app_quantfy.vars['end_date']=dt.datetime.strptime(request.form['end_date'],'%m/%d/%Y')
except ValueError:
return render_template('portfolio.html',error_end_date='<font size="3" color="red" > Wrong date format </font>')
else:
# Take today as the default date
app_quantfy.vars['end_date']=dt.datetime.today()
#print app_quantfy.vars
if 'bench_sym' in request.form:
app_quantfy.vars['bench_sym']=request.form['bench_sym']
else:
app_quantfy.vars['bench_sym']='SPY'
symbols=list(app_quantfy.vars['sym']); # Create a new list as we are doing insert operation next
symbols.insert(0,app_quantfy.vars['bench_sym']); # Insert the default symbol in the symbols list
# Here just get the data for the 'Adj. Close'
full_data=[(sym, apicall_data.get_data_from_quandl(symbol=sym, features=['Adj. Close'], start_dt=app_quantfy.vars['start_date'],end_dt=app_quantfy.vars['end_date'])
) for sym in symbols]
# Convert this to required format
df_all_sym=util.get_data(full_data)
app_quantfy.vars['guess_alloc']=request.form['guess_alloc'].strip(';').split(';')
app_quantfy.vars['start_value']=float(request.form['start_value']); # It has a default value
if len(app_quantfy.vars['guess_alloc']) !=0 and (app_quantfy.vars['guess_alloc'][0]!='') : # app_quantfy.vars['guess_alloc'] is a list because of the strip function
# print app_quantfy.vars['guess_alloc']
# print len(app_quantfy.vars['guess_alloc'])
app_quantfy.vars['guess_alloc']=[float(i) for i in app_quantfy.vars['guess_alloc']]
try:
assert len(app_quantfy.vars['guess_alloc'])==len(app_quantfy.vars['sym'])
except AssertionError:
return render_template('portfolio.html',error_alloc='<font size="3" color="red" > Number of allocations should be same as symbols </font>')
# Sum should be equal to one
print app_quantfy.vars['guess_alloc']
try:
assert abs(sum(app_quantfy.vars['guess_alloc'])-1.0)<=1e-5 # Sometimes the rounding does not work correctly
except AssertionError:
return render_template('portfolio.html',error_alloc='<font size="3" color="red" > Sum should be 1 </font>')
else:
# Generate random numbers
allocs=np.random.random(len(app_quantfy.vars['sym']))
allocs /=allocs.sum()
app_quantfy.vars['guess_alloc']=allocs
#print allocs
cr,adr,sddr,sr,ev,normalized_plot_df=optimization.access_portfolio(df_all_sym, app_quantfy.vars['bench_sym'],
app_quantfy.vars['guess_alloc'],
sv=app_quantfy.vars['start_value'])
#print cr,adr,sddr,sr,ev
param_not_opt=pd.DataFrame([cr,adr,sddr,sr,ev],index=['Cumulative Return','Average Daily Return','Stand. Deviation Daily return',
'Sharpe Ratio','End value'], columns=['Unoptimized'])
script_not_opt_table,div_not_opt_table=convert_pd_bokeh_html(param_not_opt)
# print normalized_plot_df.head()
hover=HoverTool(
tooltips=[
("Portfolio",'$y')
]
)
TOOLS='pan,wheel_zoom,box_zoom,reset,save,box_select,crosshair'
not_opt_p = figure(width=900, height=500, x_axis_type="datetime",tools=[TOOLS,hover])
colors=['blue','red','green','#cc3300']
for (i,ftr) in enumerate(normalized_plot_df):
not_opt_p.line(normalized_plot_df.index,normalized_plot_df[ftr],legend=ftr,color=colors[i],line_width=2)
#not_opt_p.line(normalized_plot_df)
not_opt_p.title.text = "Un-optimized portfolio"
not_opt_p.legend.location = "top_left"
not_opt_p.xaxis.axis_label = 'Date'
not_opt_p.yaxis.axis_label = 'Relative portfolio value'
tab_not_opt=Panel(child=not_opt_p,title='Un-optimized portfolio')
# script_not_opt, div_not_opt=components(not_opt_p)
# print script_not_opt,div_not_opt
# Now run optimized
cr,adr,sddr,sr,ev,normalized_plot_df,optimal_alloc=optimization.optimize_portfolio(df_all_sym,app_quantfy.vars['bench_sym'],
app_quantfy.vars['start_value'])
# print cr,adr,sddr,sr,ev,optimal_alloc
# print normalized_plot_df.head()
hover=HoverTool(
tooltips=[
("Portfolio",'$y')
]
)
opt_p = figure(width=900, height=500, x_axis_type="datetime",tools=[TOOLS,hover])
for (i,ftr) in enumerate(normalized_plot_df):
opt_p.line(normalized_plot_df.index,normalized_plot_df[ftr],legend=ftr,color=colors[i],line_width=2)
# print normalized_plot_df
opt_p.title.text = "Optimized portfolio value"
opt_p.legend.location = "top_left"
opt_p.xaxis.axis_label = 'Date'
opt_p.yaxis.axis_label = 'Relative portfolio value'
tab_opt=Panel(child=opt_p,title='Optimized portfolio')
tabs=Tabs(tabs=[tab_not_opt,tab_opt])
script_opt, div_opt=components(tabs)
param_opt=pd.DataFrame([cr,adr,sddr,sr,ev],index=['Cummulative Return','Additive Daily Return','Stand. Deviation Daily return',
'Sharpe Ratio','End value'], columns=['Optimized'])
all_params=param_not_opt.join(param_opt)
script_opt_table,div_opt_table=convert_pd_bokeh_html(all_params)
alloc_df=pd.DataFrame([app_quantfy.vars['guess_alloc'],list(optimal_alloc)],index=['Random/Guess allocations','Optimized allocations'],columns=app_quantfy.vars['sym'])
#str_opt_alloc='Optimal allocations: '+', '.join([str(i) for i in optimal_alloc])
script_alloc_df,div_alloc_df=convert_pd_bokeh_html(alloc_df)
# script_not_opt_table=script_not_opt_table,div_not_opt_table=div_not_opt_table,
return render_template('portfolio.html',script_opt_table=script_opt_table, div_opt_table=div_opt_table,
script_alloc_df=script_alloc_df,div_alloc_df=div_alloc_df,
script_opt=script_opt,plot_opt=div_opt
)
def compute_portvals(
orders_file,
start_val=1000000,
leverage_threshold=2.0,
bench_sym='SPY'
): # Default file is orders.csv, but the test function calls other file
#print os.path.join(UPLOAD_FOLDER,orders_file)
orders_df = get_orders(
os.path.join(UPLOAD_FOLDER,
orders_file)) # Pass the filename that was just uploaded
#print orders_df
list_symbols = list(orders_df.Symbol.unique(
)) # This gives the list of unique symbols in the order dataframe
list_symbols.insert(0, bench_sym)
# Insert the default symbol in the symbols list
# Start date should the first date in the orders file (and orders file is sorted based on dates)
start_date = orders_df.index[0]
# End date should be the last date entry in the orders file
end_date = orders_df.index[-1]
# get the price data for all the symbols in the order data frame for the date range in the order file
# Here just get the data for the 'Adj. Close'
full_data = [(sym,
apicall_data.get_data_from_quandl(symbol=sym,
features=['Adj. Close'],
start_dt=start_date,
end_dt=end_date))
for sym in list_symbols]
# Drop the bench mark price
# Convert this to required format
prices_df = util.get_data(full_data)
all_prices_df = pd.DataFrame(prices_df)
#all_prices_df.to_csv('cache/all_prices.csv')
prices_df = prices_df.drop(bench_sym, axis=1)
# Add the 'Cash' key to the price dataframe with value =1.0
prices_df['Cash'] = 1.0
# This add 1.0 to all rows in the prices_df
# create a trades dataframe and initialize
trades_df = pd.DataFrame(np.zeros(
(len(prices_df.index), len(list_symbols))),
index=prices_df.index,
columns=list_symbols)
trades_df['Cash'] = 0
# create holding dataframe and initialize
holding_df = pd.DataFrame(np.zeros(
(len(prices_df.index), len(list_symbols))),
index=prices_df.index,
columns=list_symbols)
# Initialize the cash in holding to the start value
holding_df['Cash'] = start_val
# Holding cash is same as the 'Cash' in trades_df, except we have start value initialized
# negative value of stocks in holding_df could indicate that it has
# create values dataframe and initialize
values_df = pd.DataFrame(np.zeros(
(len(prices_df.index), len(list_symbols))),
index=prices_df.index,
columns=list_symbols)
values_df['value'] = 0
# create empty dataframe for leverage
for (d, rows) in orders_df.iterrows(
): # Here d is the date index # Order file assumes that if the date is same, then they are listed as twice
if rows['Order'] == 'BUY':
trades_df.loc[d, rows['Symbol']] = rows['Shares']
trades_df.loc[d, 'Cash'] += -trades_df.loc[
d, rows['Symbol']] * prices_df.loc[d, rows['Symbol']]
# -ve indicates we have purchased the stock
# holding_df 'Cash' is the same as the trading except we have initialized to start_val
holding_df.loc[d:, 'Cash'] += -trades_df.loc[
d, rows['Symbol']] * prices_df.loc[d, rows['Symbol']]
elif rows[
'Order'] == 'SELL': # Negative value indicates you are selling
trades_df.loc[d, rows['Symbol']] = -rows['Shares']
trades_df.loc[d, 'Cash'] += -trades_df.loc[
d, rows['Symbol']] * prices_df.loc[d, rows['Symbol']]
# This will be +ve since we are selling the stock and it adds to the cash value
holding_df.loc[d:, 'Cash'] += -trades_df.loc[
d, rows['Symbol']] * prices_df.loc[d, rows['Symbol']]
holding_df.loc[d:, rows['Symbol']] += trades_df.loc[d, rows['Symbol']]
# After we update the number of holdings for each symbol and assuming only new orders are affecting the leverage, compute the leverage for this order and check against the threshold
#print holding_df.loc[d,list_symbols],prices_df.loc[d,list_symbols]
leverage = sum(holding_df.loc[d, list_symbols].abs() *
prices_df.loc[d, list_symbols]) / (
sum(holding_df.loc[d, list_symbols] *
prices_df.loc[d, list_symbols]) +
holding_df.loc[d, 'Cash'])
# Check if the threshold has crossed
if leverage > leverage_threshold:
# Then the order would not be processed
# print d, leverage
# update the holdings and trades_df based on BUY or SELL order
holding_df.loc[d:, rows['Symbol']] -= trades_df.loc[
d, rows['Symbol']] #This is same for both sell and buy
if rows['Order'] == 'BUY':
# First update the cash values back to the originals before the order
trades_df.loc[d, 'Cash'] += trades_df.loc[
d, rows['Symbol']] * prices_df.loc[d, rows['Symbol']]
holding_df.loc[d:, 'Cash'] += trades_df.loc[
d, rows['Symbol']] * prices_df.loc[d, rows['Symbol']]
# Then update the trade count (Warning: doing this first will not change the trades and holding back to its inital values)
trades_df.loc[d, rows['Symbol']] += -rows['Shares']
# print trades_df.loc[d,rows['Symbol']]
rejected_order = 'BUY'
elif rows[
'Order'] == 'SELL': # Negative value indicates you are selling
# First update cash values
trades_df.loc[d, 'Cash'] += trades_df.loc[
d, rows['Symbol']] * prices_df.loc[d, rows['Symbol']]
# This will be +ve since we are selling the stock and it adds to the cash value
holding_df.loc[d:, 'Cash'] += trades_df.loc[
d, rows['Symbol']] * prices_df.loc[d, rows['Symbol']]
# Second update the trade count
trades_df.loc[d, rows['Symbol']] += rows['Shares']
# print trades_df.loc[d,rows['Symbol']]
rejected_order = 'SELL'
print(
'This {0} order on {1} for {2} stocks has been rejected due to leverage of {3}'
.format(rejected_order, rows['Symbol'], rows['Shares'],
leverage))
values_df = prices_df * holding_df
# * in pandas gives cell-by-cell multiplication of dataframes
# print '************'
# print values_df
stocks_df = values_df[list_symbols]
#leverage_df=stocks_df.abs().sum(axis=1)/(stocks_df.sum(axis=1)+values_df['Cash']) # But you don't need this (since we calculate leverage per order basis)
# Change it to dataframe with renaming
#leverage_df=pd.DataFrame(leverage_df.ix[:],index=stocks_df.index,columns=['Leverage'])
portval = pd.DataFrame(values_df.sum(axis=1),
index=values_df.index,
columns=['Portval'])
param_df = pd.DataFrame(index=[
'Portval', 'Benchmark (' + app_marketsim.vars['bench_sym'] + ')'
],
columns=[
'Sharpe ratio', 'Cumulative Return',
'Standard Deviation', 'Average Daily Return'
])
# Compute all the fund parameters:
sharpe_ratio, cum_ret, std_daily_ret, avg_daily_ret = compute_indicators(
portval['Portval']
) # for this function to work, pass only the portval column
param_df.ix['Portval'] = [
sharpe_ratio, cum_ret, std_daily_ret, avg_daily_ret
]
# Compute benchmark parameters
sharpe_ratio_bench, cum_ret_bench, std_daily_ret_bench, avg_daily_ret_bench = compute_indicators(
all_prices_df[app_marketsim.vars['bench_sym']])
param_df.ix['Benchmark (' + app_marketsim.vars['bench_sym'] + ')'] = [
sharpe_ratio_bench, cum_ret_bench, std_daily_ret_bench,
avg_daily_ret_bench
]
#print param_df
return portval, all_prices_df, param_df, orders_df
daily_returns = compute_daily_returns(df)
volatility = get_rolling_std(daily_returns, window)
# Put the initial values to zeros,
volatility.ix[:window, :] = 0
return volatility
def requested_params():
return
if __name__ == '__main__':
symbols = ['SPY', 'GOOG']
full_data = [
(sym,
apicall_data.get_data_from_quandl(
sym,
start_dt=dt.datetime.today() - dt.timedelta(days=5 * 365),
end_dt=dt.datetime.today())) for sym in symbols
]
print full_data
df = get_data(full_data)
rm = get_rolling_mean(df, window=20)
rstd = get_rolling_std(df, window=20)
u_band, l_band = get_bollinger_bands(rm, rstd)
#print u_band.columns
#print l_band.columns