Spaces:
Sleeping
Sleeping
| import pandas as pd | |
| import numpy as np | |
| import yfinance as yf | |
| import streamlit as st | |
| import plotly.graph_objects as go | |
| import time | |
| import datetime | |
| from utilities.checker import moving_average, percentage_return | |
| with open(r"style/style.css") as css: | |
| st.markdown(f"<style>{css.read()}</style>", unsafe_allow_html=True) | |
| st.markdown( | |
| "<h1 style='text-align: center;'><u>CapiPort</u></h1>", unsafe_allow_html=True | |
| ) | |
| st.markdown( | |
| "<h5 style='text-align: center; color: gray;'>Your Portfolio Optimisation Tool</h5>", | |
| unsafe_allow_html=True, | |
| ) | |
| st.header( | |
| "", | |
| divider="rainbow", | |
| ) | |
| color = "Quest" | |
| st.markdown( | |
| "<h1 style='text-align: center;'>🔍 Quest for financial excellence begins with meticulous portfolio optimization</u></h1>", | |
| unsafe_allow_html=True, | |
| ) | |
| st.header( | |
| "", | |
| divider="rainbow", | |
| ) | |
| list_df = pd.read_csv("Data/Company List.csv") | |
| company_name = list_df["Name"].to_list() | |
| company_symbol = (list_df["Ticker"] + ".NS").to_list() | |
| company_dict = dict() | |
| company_symbol_dict = dict() | |
| for CSymbol, CName in zip(company_symbol, company_name): | |
| company_dict[CName] = CSymbol | |
| for CSymbol, CName in zip(company_symbol, company_name): | |
| company_symbol_dict[CSymbol] = CName | |
| st.markdown( | |
| """ | |
| <style> | |
| .big-font { | |
| font-size:20px; | |
| } | |
| </style>""", | |
| unsafe_allow_html=True, | |
| ) | |
| st.markdown('<p class="big-font">Select Multiple Companies</p>', unsafe_allow_html=True) | |
| com_sel_name = st.multiselect("", company_name, default=None) | |
| com_sel_date = [] | |
| for i in com_sel_name: | |
| d = st.date_input( | |
| f"On which date did you invested in - {i}", | |
| value=pd.Timestamp("2021-01-01"), | |
| format="YYYY-MM-DD", | |
| ) | |
| d = d - datetime.timedelta(days=3) | |
| com_sel_date.append(d) | |
| com_sel = [company_dict[i] for i in com_sel_name] | |
| num_tick = len(com_sel) | |
| if num_tick > 1: | |
| com_data = pd.DataFrame() | |
| for cname, cdate in zip(com_sel, com_sel_date): | |
| stock_data_temp = yf.download( | |
| cname, start=cdate, end=pd.Timestamp.now().strftime("%Y-%m-%d") | |
| )["Low"] | |
| stock_data_temp.name = cname | |
| com_data = pd.merge( | |
| com_data, stock_data_temp, how="outer", right_index=True, left_index=True | |
| ) | |
| for i in com_data.columns: | |
| com_data.dropna(axis=1, how="all", inplace=True) | |
| # com_data.dropna(inplace=True) | |
| num_tick = len(com_data.columns) | |
| # Dataframe of the selected companies | |
| st.dataframe(com_data, use_container_width=True) | |
| # make a function to calculate moving averages from the dataframe com_data, store those moving averages in dictionary for respective company | |
| moving_avg = moving_average(com_data, 3) | |
| MA_df = pd.DataFrame(moving_avg.items(), columns=["Company", "Purchase Rate (MA)"]) | |
| # calculate percentage return till present date from the moving average price of the stock | |
| # make percentage return a dataframe from dictionary | |
| percentage_return = pd.DataFrame( | |
| percentage_return(com_data, moving_avg).items(), | |
| columns=["Company", "Percentage Return"], | |
| ) | |
| # merge MA_df and percentage_return on "Company" columns | |
| MA_df = pd.merge(MA_df, percentage_return, on="Company") | |
| st.markdown( | |
| "<h5 style='text-align: center;'>Percent Returns & MA price</h5>", | |
| unsafe_allow_html=True, | |
| ) | |
| st.write( | |
| "<p style='text-align: center;'>**rate of purchase is moving average(MA) of 3 (t+2) days</p>", | |
| unsafe_allow_html=True, | |
| ) | |
| st.dataframe(MA_df, use_container_width=True) | |
| if num_tick > 1: | |
| com_sel_name_temp = [] | |
| for i in com_data.columns: | |
| com_sel_name_temp.append(company_symbol_dict[i]) | |
| com_sel = com_data.columns.to_list() | |
| ## Log-Return of Company Dataset | |
| log_return = np.log(1 + com_data.pct_change()) | |
| ## Generate Random Weights | |
| rand_weig = np.array([100 / len(com_sel)] * len(com_sel)) | |
| ## Rebalancing Random Weights | |
| rebal_weig = rand_weig / np.sum(rand_weig) | |
| ## Calculate the Expected Returns, Annualize it by * 252.0 | |
| exp_ret = np.sum((log_return.mean() * rebal_weig) * 252) | |
| ## Calculate the Expected Volatility, Annualize it by * 252.0 | |
| exp_vol = np.sqrt( | |
| np.dot(rebal_weig.T, np.dot(log_return.cov() * 252, rebal_weig)) | |
| ) | |
| ## Calculate the Sharpe Ratio. | |
| sharpe_ratio = exp_ret / exp_vol | |
| # Put the weights into a data frame to see them better. | |
| weights_df = pd.DataFrame( | |
| data={ | |
| "company_name": com_sel_name_temp, | |
| "rebalance_weights": rebal_weig, | |
| } | |
| ) | |
| st.markdown( | |
| "<h5 style='text-align: center;'>Random Portfolio Weights</h5>", | |
| unsafe_allow_html=True, | |
| ) | |
| st.dataframe(weights_df, use_container_width=True) | |
| # Do the same with the other metrics. | |
| metrics_df = pd.DataFrame( | |
| data={ | |
| "Expected Portfolio Returns": exp_ret, | |
| "Expected Portfolio Volatility": exp_vol, | |
| "Portfolio Sharpe Ratio": sharpe_ratio, | |
| }, | |
| index=[0], | |
| ) | |
| st.markdown( | |
| "<h5 style='text-align: center;'>Random Weights Metrics</h5>", | |
| unsafe_allow_html=True, | |
| ) | |
| st.dataframe(metrics_df, use_container_width=True) | |
| ## Let's get started with Monte Carlo Simulations | |
| ## How many times should we run Monte Carlo | |
| num_of_port = 8000 | |
| ## Create an Array to store the weights as they are generated | |
| all_weights = np.zeros((num_of_port, num_tick)) | |
| ## Create an Array to store the returns as they are generated | |
| ret_arr = np.zeros(num_of_port) | |
| ## Create an Array to store the volatilities as they are generated | |
| vol_arr = np.zeros(num_of_port) | |
| ## Create an Array to store the Sharpe Ratios as they are generated | |
| sharpe_arr = np.zeros(num_of_port) | |
| ## Track Progress with a Bar | |
| progress_text = "Simulations in progress. Please wait." | |
| my_bar = st.progress(0, text=progress_text) | |
| ## Let's start the Monte Carlo Simulation | |
| for ind in range( | |
| num_of_port | |
| ): # Corrected the range to iterate from 0 to num_of_port | |
| time.sleep(0.001) | |
| ## Let's first Calculate the Weights | |
| weig = np.array(np.random.random(num_tick)) | |
| weig = weig / np.sum(weig) | |
| ## Append the Weights to Weigths array | |
| all_weights[ind, :] = weig | |
| ## Calculate and Append the Expected Log Returns to Returns Array | |
| ret_arr[ind] = np.sum((log_return.mean() * weig) * 247) | |
| ## Calculate and Append the Volatility to the Volatitlity Array | |
| vol_arr[ind] = np.sqrt(np.dot(weig.T, np.dot(log_return.cov() * 247, weig))) | |
| ## Calculate and Append the Sharpe Ratio to Sharpe Ratio Array | |
| sharpe_arr[ind] = ret_arr[ind] / vol_arr[ind] | |
| if ind % 100 == 0: | |
| my_bar.progress((ind + 1) / num_of_port, text=progress_text) | |
| # clear progress bar | |
| my_bar.empty() | |
| ## Let's create a Data Frame with Weights, Returns, Volatitlity, and the Sharpe Ratio | |
| sim_data = [ret_arr, vol_arr, sharpe_arr, all_weights] | |
| ## Create a Data Frame using above, then Transpose it | |
| sim_df = pd.DataFrame(data=sim_data).T | |
| ## Give the columns in Simulation Data Proper Names | |
| sim_df.columns = ["Returns", "Volatility", "Sharpe Ratio", "Portfolio Weights"] | |
| ## Make sure the Data Types are correct in the Data Frame | |
| sim_df = sim_df.infer_objects() | |
| # Print out the results. | |
| st.write("\n\n") | |
| st.markdown( | |
| "<h4 style='text-align: center;'>Simulation Results</h4>", | |
| unsafe_allow_html=True, | |
| ) | |
| st.dataframe(sim_df.head(), use_container_width=True) | |
| # Return the Max Sharpe Ratio from the run. | |
| max_sharpe_ratio = sim_df.loc[sim_df["Sharpe Ratio"].idxmax()] | |
| # Return the Min Volatility from the run. | |
| min_volatility = sim_df.loc[sim_df["Volatility"].idxmin()] | |
| max_sharpe_weights_df = pd.DataFrame( | |
| data={ | |
| "company_name": com_sel_name_temp, | |
| "random_weights": max_sharpe_ratio["Portfolio Weights"], | |
| } | |
| ) | |
| st.markdown( | |
| "<h5 style='text-align: center;'>Portfolio with Max Sharpe Ratio</h5>", | |
| unsafe_allow_html=True, | |
| ) | |
| st.dataframe(max_sharpe_ratio, use_container_width=True) | |
| st.dataframe(max_sharpe_weights_df, use_container_width=True) | |
| min_volatility_weights_df = pd.DataFrame( | |
| data={ | |
| "company name": com_sel_name_temp, | |
| "optimized weights": min_volatility["Portfolio Weights"], | |
| } | |
| ) | |
| st.markdown( | |
| "<h5 style='text-align: center;'>Portfolio with Min Volatility</h5>", | |
| unsafe_allow_html=True, | |
| ) | |
| st.dataframe(min_volatility, use_container_width=True) | |
| st.dataframe(min_volatility_weights_df, use_container_width=True) | |
| st.divider() | |
| st.markdown( | |
| "<h1 style='text-align: center;'>Plotting</h1>", unsafe_allow_html=True | |
| ) | |
| # plot a pie chart using plotly for max sharpe ratio | |
| fig = go.Figure( | |
| data=go.Pie( | |
| labels=com_sel_name_temp, | |
| values=max_sharpe_ratio["Portfolio Weights"], | |
| hole=0.3, | |
| textinfo="percent+label", # Information to display on the pie slices | |
| hoverinfo="label+percent", # Information to display on hover | |
| marker=dict(line=dict(color="white", width=2)), | |
| ) | |
| ) | |
| # update colors | |
| fig.update_traces( | |
| marker=dict( | |
| colors=[ | |
| "lightseagreen", | |
| "lightcoral", | |
| "lightskyblue", | |
| "lightgreen", | |
| "lightpink", | |
| "lightyellow", | |
| "lightblue", | |
| "lightgrey", | |
| "lightgoldenrodyellow", | |
| "lightcyan", | |
| ] | |
| ) | |
| ) | |
| # update layout of the pie chart | |
| # Add color bar | |
| fig.update_layout(coloraxis_colorbar=dict(title="Sharpe Ratio")) | |
| # Add title and axis labels | |
| fig.update_layout( | |
| title="Portfolio Composition", | |
| showlegend=False, | |
| height=500, | |
| width=700, | |
| margin=dict(l=50, r=50, t=50, b=50), | |
| ) | |
| st.plotly_chart(fig, use_container_width=True) | |