def data() -> pd.DataFrame:
chosen_stocks = list(params.get("STOCKS_INFO").keys())
params["chosen_stocks"] = chosen_stocks
params["stocks_info"] = params.get("STOCKS_INFO")
params["START_DATE"] = get_start_date()
params["END_DATE"] = get_end_date()
params["STOCKS_LIST"] = get_list_stocks()
data_step0 = get_data(params)
data_step1 = process_data(data_step0, params)
covariance_tbl = get_covariance_tbl(data_step1)
correlation_tbl = get_correlation_tbl(data_step1)
portfolio_properties = get_portfolio_properties(data_step1, params)
yearly_returns = get_returns(data_step1)
volatility_yearly = get_volatility_yearly(data_step1)
portfolio_info = pd.merge(
portfolio_properties.share_allocation_df,
yearly_returns,
how="left",
on="stock_name",
)
portfolio_info = pd.merge(
portfolio_info, volatility_yearly, how="left", on="stock_name"
)
data_step2 = get_stock_data_returns(data_step1, params)
data = data_step2
return data
def test_scatter_matrix_plot(self, data: pd.DataFrame):
crypto_comp = pd.concat(
[data[stock]["Open"] for stock in params.get("STOCK_CODES")], axis=1
)
crypto_comp.columns = [
f"{stock.capitalize()} Open" for stock in params.get("STOCK_CODES")
]
fig = px.scatter_matrix(crypto_comp)
fig.show()
def data() -> pd.DataFrame:
chosen_stocks = list(params.get("STOCKS_INFO").keys())
params["chosen_stocks"] = chosen_stocks
params["stocks_info"] = params.get("STOCKS_INFO")
params["START_DATE"] = get_start_date()
params["END_DATE"] = get_end_date()
params["STOCKS_LIST"] = get_list_stocks()
data_step0 = get_data(params)
data_step1 = process_data(data_step0, params)
return data_step1
def test_returns_scatter_matrix_plot(self, stock_data_returns: pd.DataFrame):
returns_comp = pd.concat(
[
stock_data_returns.query(f'stock_name=="{stock}"')["returns"]
for stock in params.get("STOCK_CODES")
], axis=1
)
returns_comp.columns = [
f"{stock.capitalize()} returns" for stock in params.get("STOCK_CODES")
]
fig = px.scatter_matrix(returns_comp)
fig.show()
def data_step0() -> pd.DataFrame:
### get_data
chosen_stocks = list(params.get("STOCKS_INFO").keys())
start_date = params.get("START_DATE")
end_date = params.get("END_DATE")
stocks_info = params.get("STOCKS_INFO")
chosen_stocks = None
if not chosen_stocks:
chosen_stocks = [stock_name for stock_name, stock in stocks_info.items()]
chosen_codes = [stocks_info[stock_name].code for stock_name in chosen_stocks]
data_step0 = web.DataReader(chosen_codes, "yahoo", start=start_date, end=end_date)
return data_step0
def test_dist_returns_plots(self, stock_data_returns: pd.DataFrame):
hist_data = [
stock_data_returns.query(f'stock_name=="{stock}"')["returns"]
for stock in params.get("STOCK_CODES")
]
group_labels = [stock for stock in params.get("STOCK_CODES")]
try:
fig = ff.create_distplot(hist_data, group_labels, bin_size=0.01)
except ValueError:
for data in hist_data:
data.dropna(inplace=True)
fig = ff.create_distplot(hist_data, group_labels, bin_size=0.01)
fig.show()
def scatter_plot(data: pd.DataFrame) -> None:
variable = "Open"
title = f"Scatter Matrix for {variable} Prices"
components = pd.concat(
[
data.query(f'stock_name=="{stock_name}"')[variable]
for stock_name in params.get("STOCKS_INFO")
],
axis=1,
)
components.columns = [
f"{stock.capitalize()} {variable}" for stock in params.get("STOCKS_INFO")
]
fig = px.scatter_matrix(components, title=title)
def investment_data() -> pd.DataFrame:
d = defaultdict(list)
for field in Stock._fields:
for stock_name, stock_obj in params.get("STOCKS_INFO").items():
d[field].append(getattr(stock_obj, field))
df = pd.DataFrame.from_dict(d)
return df
def stock_data_tas(stock_data:pd.DataFrame) -> pd.DataFrame:
datas=[]
for stock_name in params.get('STOCK_CODES'):
datas.append(get_technical_analysis(stock_data, stock_name))
data = pd.concat(datas)
return data
def get_total_cum_profits(stock_data: pd.DataFrame,
strategy_profit_name: str) -> pd.DataFrame:
profits = [
stock_data.query(f'stock_name=="{stock}"')[[
strategy_profit_name, 'stock_name'
]] for stock in params.get('STOCK_CODES')
]
total_cum_profits = deepcopy(profits[0])
total_cum_profits = total_cum_profits[~total_cum_profits.index.duplicated(
)]
indexes = total_cum_profits.index
for i in range(1, len(profits)):
profits_stock = profits[i]
profits_stock = profits_stock[~profits_stock.index.duplicated()]
total_cum_profits[strategy_profit_name] += profits_stock[
strategy_profit_name]
total_cum_profits_df = pd.DataFrame.from_dict({
strategy_profit_name:
total_cum_profits[strategy_profit_name],
'stock_name': [
'Total Strategy Cumulative Profits'
for _ in range(len(total_cum_profits))
]
})
total_cum_profits_df.index = indexes
return total_cum_profits_df
def test_get_investment_data(self) -> None:
chosen_stocks = list(params.get("STOCKS_INFO").keys())
investment_data = get_investment_data(params)
for field in Stock._fields:
assert field in investment_data.columns
assert investment_data.shape == (len(chosen_stocks), len(Stock._fields))
def data_step1(data_step0: pd.DataFrame) -> pd.DataFrame:
code_name_mapping = params.get("CODE_NAME_MAPPING")
code_rank_mapping = params.get("CODE_RANK_MAPPING")
stocks_data = data_step0.stack()
dates = [idx[0] for idx in stocks_data.index]
stocks_data = stocks_data.reset_index(drop=False)
stocks_data.index = dates
stocks_data.rename(columns={"Symbols": "stock_code"}, inplace=True)
stocks_data["stock_name"] = stocks_data.stock_code.apply(
lambda code: code_name_mapping.get(code)
)
stocks_data["sector"] = stocks_data.stock_code.apply(
lambda x: code_rank_mapping.get(x)
)
data_step1 = stocks_data.sort_values(["stock_name", "Date"])
return data_step1
def test_get_strategy_profits_all(self, inf_data: tuple):
information, stock_data = inf_data
data = pd.concat([
get_strategy_profits(stock_data, stock, 'orders_ma_nb')
for stock in params.get('STOCK_CODES')
])
assert 'orders_ma_cum_profits' in data.columns
assert stock_data.shape[0] == data.shape[0]
def stock_data(data: dict) -> pd.DataFrame:
stocks = list(params.get("STOCK_CODES").keys())
data = get_data(params, stocks=["bitcoin", "ethereum"])
stock_data = stack_data(data)
stock_data["Total Traded"] = stock_data["Open"] * stock_data["Volume"]
stock_data = get_moving_averages(stock_data, params)
stock_data = get_stock_data_returns(stock_data, params)
stock_data = get_technical_analysis_all(stock_data, params)
stock_data = ma_trading(stock_data)
return stock_data
def add_layout_components_for_multiple_plots(plot_func: FunctionType,
data: pd.DataFrame,
params: dict) -> list:
"""
Creates a list with [graph, html.Hr(), graph, html.Hr(), ...]
to be further unpacked in the layout
"""
plots_lst = []
for stock in params.get("chosen_stocks"):
graph, hr = dcc.Graph(figure=plot_func(data, stock)), html.Hr()
plots_lst.append(graph), plots_lst.append(hr)
return plots_lst
def test_simulated_stocks_plot(self, data: pd.DataFrame) -> None:
params['num_simulations_stock'] = 100
chosen_stocks = list(params.get("STOCKS_INFO").keys())
params["chosen_stocks"] = chosen_stocks
simulated_stocks = get_simulated_stocks(data, params)
stock_name = "Nestlé"
df_simulated_stock = get_df_simulated_stock(
stock_name, simulated_stocks, params
)
fig = plot_simulated_stocks(
df_simulated_stock, "Adj Close Price simulated", "Simulated Stock Prices"
)
fig.show()
def nb_count_orders_all(self, inf_data: pd.DataFrame) -> pd.DataFrame:
strategy_name = 'orders_ma_signal'
for i, stock in enumerate(params.get('STOCK_CODES')):
if i == 0:
data_basis = get_count_orders(stock_data, stock, strategy_name)
if i > 0:
data = get_count_orders(stock_data, stock, strategy_name)
data_basis = pd.merge(data_basis,
data,
how='left',
on='variable_name')
nb_count_orders_all = data_basis
return nb_count_orders_all
def inf_data() -> tuple:
stocks = list(params.get("STOCK_CODES").keys())
data = get_data(params, stocks=["bitcoin", "ethereum"])
stock_data = stack_data(data)
stock_data["Total Traded"] = stock_data["Open"] * stock_data["Volume"]
dates_vol_traded = [
get_date_max_min_volume_traded(stock_data, stock) for stock in stocks
]
information = pd.merge(*dates_vol_traded, on="variable_name")
stock_data = get_moving_averages(stock_data, params)
stock_data = get_stock_data_returns(stock_data, params)
stock_data = get_technical_analysis_all(stock_data, params)
stock_data = ma_trading(stock_data)
stock_data = bollinger_bands_trading(stock_data)
stock_data = rsi_trading(stock_data)
inf_data = information, stock_data
return inf_data
def test_simulated_optimal_portfolio(
self, data: pd.DataFrame, portfolios_simulated: pd.DataFrame
) -> None:
chosen_stocks = list(params.get("STOCKS_INFO").keys())
params["chosen_stocks"] = chosen_stocks
params["data_range"] = get_data_range(data, params)
params['num_simulations_stock'] = 100
params['lower_quantile_lvl'] = 0.05
params['upper_quantile_lvl'] = 0.95
optimal_portfolio = get_portfolio_with(
portfolios_simulated,
lowest_volatility=True,
highest_return=True,
pretty_print_perc=False,
)
sim = get_simulations(data, optimal_portfolio, params)
fig = plot_simulated_stocks(
sim.simulations_optimal_portfolio_df,
y="Adj Close Price simulated",
title="Optimal Portfolio simulations",
)
fig.show()
f"Simulated {stock_name} Prices",
)
components.append(dcc.Graph(figure=fig)), components.append(html.Hr())
return components
def add_layout_components_for_multiple_plots(plot_func: FunctionType,
data: pd.DataFrame,
params: dict) -> list:
"""
Creates a list with [graph, html.Hr(), graph, html.Hr(), ...]
to be further unpacked in the layout
"""
plots_lst = []
for stock in params.get("chosen_stocks"):
graph, hr = dcc.Graph(figure=plot_func(data, stock)), html.Hr()
plots_lst.append(graph), plots_lst.append(hr)
return plots_lst
stock_list_dropdown = dcc.Dropdown(
id="chosen-stocks",
options=[{
"label": stock,
"value": stock
} for stock in params.get("STOCKS_INFO")],
multi=True,
searchable=True,
value=list(params.get("STOCKS_INFO").keys()),
)
def get_strategy_profits_all(stock_data: pd.DataFrame,
strategy_order_name: str) -> pd.DataFrame:
return pd.concat([
get_strategy_profits(stock_data, stock, strategy_order_name)
for stock in params.get('STOCK_CODES')
])
def get_layout(params: dict) -> html.Div:
layout = html.Div(children=[
html.H1(children="Trading Dashboard"),
dcc.Tabs([
dcc.Tab(label="DEBUG"),
dcc.Tab(
label="Prices time series",
children=[
dcc.Dropdown(
id="chosen-stocks",
options=[{
"label": stock,
"value": stock
} for stock in params.get("STOCK_CODES")],
multi=True,
searchable=True,
value=list(params.get("STOCK_CODES").keys()),
),
dcc.Graph(figure=params.get("open_prices_plot")),
*params.get('high_low_plots_lst'),
dcc.Graph(figure=params.get("volume_plot")),
dcc.Graph(figure=params.get("total_traded_plot")),
*params.get('moving_average_plots_lst'),
dcc.Graph(figure=params.get("scatter_matrix_plot")),
html.Div('Distribution of Returns'),
dcc.Graph(figure=params.get("dist_returns_plots")),
dcc.Graph(
figure=params.get("returns_scatter_matrix_plot")),
dcc.Graph(figure=params.get("cum_return_plot")),
],
),
dcc.Tab(label='Trading analysis',
children=[
*params.get('moving_average_plots_lst'),
*params.get('bolliger_bans_plots_lst'),
dcc.Graph(figure=params.get("rsi_plot")),
dcc.Graph(
figure=params.get("orders_ma_cum_profits_plot")),
dcc.Graph(
figure=params.get("orders_bb_cum_profits_plot")),
dcc.Graph(
figure=params.get("orders_rsi_cum_profits_plot")),
]),
dcc.Tab(
label="Some information",
children=[
dash_table.DataTable(
columns=[{
"name": i,
"id": i
} for i in params.get("information").columns],
data=params.get("information").to_dict("records"),
),
html.Hr(),
html.Div(
'We present here some risk measures for all trading strategies'
),
params.get('all_strategy_risk_measures')
],
),
]),
])
return layout
def main():
###########################################################
################# BACKEND #################
###########################################################
chosen_stocks = params.get('chosen_stocks')
investment_data = get_investment_data(params)
your_investment_data = investment_data[investment_data.name.isin(chosen_stocks)]
data_step0 = get_data(params)
data_step1 = process_data(data_step0, params)
covariance_tbl = get_covariance_tbl(data_step1)
correlation_tbl = get_correlation_tbl(data_step1)
portfolio_properties = get_portfolio_properties(data_step1, params)
yearly_returns = get_returns(data_step1)
volatility_yearly = get_volatility_yearly(data_step1)
portfolio_info = pd.merge(
portfolio_properties.share_allocation_df,
yearly_returns,
how="left",
on="stock_name",
)
portfolio_info = pd.merge(
portfolio_info, volatility_yearly, how="left", on="stock_name"
)
data_step2 = get_stock_data_returns(data_step1, params)
portfolios_simulated = run_portfolios_simulations(
data_step1, params
)
optimal_portfolio = get_portfolio_with(
portfolios_simulated,
lowest_volatility=True,
highest_return=True,
pretty_print_perc=False,
)
params["data_range"] = get_data_range(data_step2, params)
sim = get_simulations(data_step2, optimal_portfolio, params)
summary_msg = get_investment_summary(portfolios_simulated, sim, params)
data = data_step2
###########################################################
################# FRONTEND #################
###########################################################
params["data"] = data
params["data_range"] = get_data_range(data, params)
params["your_investment_data"] = get_data_table(your_investment_data)
params["open_prices_plot_all"] = plot(data, "Open", "Open prices")
params["open_prices_plot_lst"] = add_layout_components_for_multiple_plots(
plot_low_high_prices, data, params
)
params["covariance_tbl_dt"] = get_data_table(covariance_tbl)
params["correlation_tbl_dt"] = get_data_table(
correlation_tbl, pretty_print_perc=True
)
params["open_scatter_matrix"] = plot_scatter_matrix(data, params, "Open")
params[
"default_portfolio_variance"
] = portfolio_properties.variance_portfolio_return
params["default_portfolio_expected_return"] = "{:.2%}".format(
portfolio_properties.expected_portfolio_return
)
params["portfolio_info_dt"] = get_data_table(portfolio_info, pretty_print_perc=True)
params["dist_returns_plot"] = plot_dist_returns(data, params)
params[
"efficient_frontier_optimal_point_plot"
] = plot_efficient_frontier_optimal_point(portfolios_simulated)
params[
"efficient_frontier_continuous_color_plot"
] = plot_efficient_frontier_continuous_color(portfolios_simulated)
params["portfolios_simulated_dt"] = get_data_table(
portfolios_simulated, pretty_print_perc=True
)
params["summary_msg"] = summary_msg
params[
"simulated_stock_plots_lst"
] = add_layout_compoment_for_simulated_stock_plots(data, sim.simulated_stocks)
params["simulations_optimal_portfolio_plot"] = plot_simulated_stocks(
sim.simulations_optimal_portfolio_df,
y="Adj Close Price simulated",
title="Optimal Portfolio simulations",
)
params['investment_data_component'] = html.Ul(
children=[html.Li(f"{k}:\t{v}") for k, v in params.items() if k in params.get('params_to_show')]
)
app.layout = get_layout(params)
app.run_server(debug=True)
def main():
###########################################################
################# BACKEND #################
###########################################################
# TODO:user input
# risk measure
stocks = params.get("chosen_stocks")
data = get_data(params, stocks=stocks)
stock_data = stack_data(data)
stock_data["Total Traded"] = stock_data["Open"] * stock_data["Volume"]
dates_vol_traded = [
get_date_max_min_volume_traded(stock_data, stock) for stock in stocks
]
information = dates_vol_traded[0]
for i in range(1, len(dates_vol_traded)):
information = pd.merge(information,
dates_vol_traded[i],
on="variable_name")
stock_data = get_moving_averages(stock_data, params)
stock_data = get_stock_data_returns(stock_data, params)
stock_data = get_technical_analysis_all(stock_data, params)
stock_data = ma_trading(stock_data)
stock_data = bollinger_bands_trading(stock_data)
stock_data = rsi_trading(stock_data)
count_orders = get_count_orders_all_strat(stock_data, params)
information = pd.concat([information, count_orders])
all_strat_risk_measures = get_all_strategy_risk_measures(stock_data)
params["information"] = information
###########################################################
################# FRONT END #################
###########################################################
params["open_prices_plot"] = plot(stock_data,
y="Open",
title="Open Prices")
high_low_plots_lst = []
for stock in stocks:
high_low_plots_lst.append(
dcc.Graph(figure=plot_low_high_prices(data[stock], stock)))
high_low_plots_lst.append(html.Hr())
params['high_low_plots_lst'] = high_low_plots_lst
params["volume_plot"] = plot(stock_data, y="Volume", title="Volume traded")
params["total_traded_plot"] = plot(stock_data,
y="Total Traded",
title="Total Traded")
params['moving_average_plots_lst'] = add_multiplots_components(
stock_data, plot_moving_average)
params["scatter_matrix_plot"] = plot_scatter_matrix(data, params)
params["dist_returns_plots"] = plot_dist_returns(stock_data, params)
params["returns_scatter_matrix_plot"] = plot_returns_scatter_matrix(
stock_data, params)
params["cum_return_plot"] = plot_cum_return(stock_data)
params["rsi_plot"] = plot_rsi(stock_data)
params['orders_ma_cum_profits_plot'] = plot_cum_profits(
stock_data, 'orders_ma_cum_profits', params, 'MA')
params['orders_bb_cum_profits_plot'] = plot_cum_profits(
stock_data, 'orders_bb_cum_profits', params, 'BB')
params['orders_rsi_cum_profits_plot'] = plot_cum_profits(
stock_data, 'orders_rsi_cum_profits', params, 'RSI')
params['bolliger_bans_plots_lst'] = add_multiplots_components(
stock_data, plot_bollinger_bands)
params['all_strategy_risk_measures'] = get_data_table(
all_strat_risk_measures)
app.layout = get_layout(params)
app.run_server(debug=True)
def get_technical_analysis_all(stock_data: pd.DataFrame,
params: dict) -> pd.DataFrame:
return pd.concat([
get_technical_analysis(stock_data, stock_name)
for stock_name in params.get('STOCK_CODES')
])
import dash
from src.constants import params
from src.utils import *
__all__ = ['app']
app = dash.Dash(__name__, external_stylesheets=params.get("STYLE_SHEET"))
def stock_data_returns(stock_data: pd.DataFrame) -> pd.DataFrame:
stock_data_returns = pd.concat(
[get_return(stock_data, stock) for stock in params.get("STOCK_CODES")]
)
return stock_data_returns
def test_information_tbl(self, inf_data: tuple):
information, _ = inf_data
stocks = list(params.get("STOCK_CODES").keys())
for stock in stocks:
assert stock in information.columns
def test_get_data(self):
data_step0 = get_data(params)
chosen_codes = [stock.code for stock in params.get("STOCKS_INFO").values()]
for multi_idx in data_step0.columns:
assert multi_idx[1] in set(chosen_codes)
def test_preprocess_data(self, data_step0):
data_step1 = process_data(data_step0, params)
chosen_codes = [stock.code for stock in params.get("STOCKS_INFO").values()]
for col in ["stock_name", "stock_code", "sector"]:
assert col in data_step1.columns
