import streamlit as st
from datetime import date
import yfinance as yf
import numpy as np
import pandas as pd
import plotly.express as px
import plotly.graph_objs as go
import plotly.subplots as sp
from plotly.subplots import make_subplots
import plotly.figure_factory as ff
import plotly.io as pio
from IPython.display import display
from plotly.offline import init_notebook_mode
init_notebook_mode(connected=True)
import time
from requests.exceptions import RequestException
from json.decoder import JSONDecodeError
import warnings
# Hiding Warnings
warnings.filterwarnings('ignore')
def perform_portfolio_analysis(df, tickers_weights):
"""
This function takes historical stock data and the weights of the securities in the portfolio,
It calculates individual security returns, cumulative returns, volatility, and Sharpe Ratios.
It then visualizes this data, showing historical performance and a risk-reward plot.
Parameters:
- df (pd.DataFrame): DataFrame containing historical stock data with securities as columns.
- tickers_weights (dict): A dictionary where keys are ticker symbols (str) and values are their
respective weights (float)in the portfolio.
Returns:
- fig1: A Plotly Figure with two subplots:
1. Line plot showing the historical returns of each security in the portfolio.
2. Plot showing the annualized volatility and last cumulative return of each security
colored by their respective Sharpe Ratio.
Notes:
- The function assumes that 'pandas', 'numpy', and 'plotly.graph_objects' are imported as 'pd', 'np', and 'go' respectively.
- The function also utilizes 'plotly.subplots.make_subplots' for creating subplots.
- The risk-free rate is assumed to be 1% per annum for Sharpe Ratio calculation.
"""
# Starting DataFrame and Series
individual_cumsum = pd.DataFrame()
individual_vol = pd.Series(dtype=float)
individual_sharpe = pd.Series(dtype=float)
# Iterating through tickers and weights in the tickers_weights dictionary
for ticker, weight in tickers_weights.items():
if ticker in df.columns: # Confirming that the tickers are available
individual_returns = df[ticker].pct_change() # Computing individual daily returns for each ticker
individual_cumsum[ticker] = ((1 + individual_returns).cumprod() - 1) * 100 # Computing cumulative returns over the period for each ticker
vol = (individual_returns.std() * np.sqrt(252)) * 100 # Computing annualized volatility
individual_vol[ticker] = vol # Adding annualized volatility for each ticker
individual_excess_returns = individual_returns - 0.01 / 252 # Computing the excess returns
sharpe = (individual_excess_returns.mean() / individual_returns.std() * np.sqrt(252)).round(2) # Computing Sharpe Ratio
individual_sharpe[ticker] = sharpe # Adding Sharpe Ratio for each ticker
# Creating subplots for comparison across securities
fig1 = make_subplots(rows = 1, cols = 2, horizontal_spacing=0.25,
column_titles=['Historical Performance Assets', 'Risk-Reward'],
column_widths=[.55, .45],
shared_xaxes=False, shared_yaxes=False)
# Adding the historical returns for each ticker on the first subplot
for ticker in individual_cumsum.columns:
fig1.add_trace(go.Scatter(x=individual_cumsum.index,
y=individual_cumsum[ticker],
mode = 'lines',
name = ticker,
hovertemplate = '%{y:.2f}%',
showlegend=True),
row=1, col=1)
# Defining colors for markers on the second subplot
sharpe_colors = [individual_sharpe[ticker] for ticker in individual_cumsum.columns]
# Adding markers for each ticker on the second subplot
fig1.add_trace(go.Scatter(x=individual_vol.tolist(),
y=individual_cumsum.iloc[-1].tolist(),
mode='markers+text',
marker=dict(size=75, color = sharpe_colors,
colorscale = 'Bluered_r',
colorbar=dict(title='Sharpe Ratio'),
showscale=True),
name = 'Returns',
text = individual_cumsum.columns.tolist(),
textfont=dict(color='white'),
showlegend=False,
hovertemplate = '%{y:.2f}%
Annualized Volatility: %{x:.2f}%
Sharpe Ratio: %{marker.color:.2f}',
textposition='middle center'),
row=1, col=2)
# Updating layout
fig1.update_layout(title={
'text': f'Portfolio Analysis',
'font': {'size': 24}
},
template = 'plotly_white',
height = 650, width = 1250,
hovermode = 'x unified',
legend_x=.45,
legend_y=.5)
fig1.update_yaxes(title_text='Returns (%)', col=1)
fig1.update_yaxes(title_text='Returns (%)', col = 2)
fig1.update_xaxes(title_text = 'Date', col = 1)
fig1.update_xaxes(title_text = 'Annualized Volatility (%)', col =2)
return fig1 # Returning figure
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
def portfolio_vs_benchmark(port_returns, benchmark_returns):
"""
This function calculates and displays the cumulative returns, annualized volatility, and Sharpe Ratios
for both the portfolio and the benchmark. It provides a side-by-side comparison to assess the portfolio's
performance relative to the benchmark.
Parameters:
- port_returns (pd.Series): A Pandas Series containing the daily returns of the portfolio.
- benchmark_returns (pd.Series): A Pandas Series containing the daily returns of the benchmark.
Returns:
- fig2: A Plotly Figure object with two subplots:
1. Line plot showing the cumulative returns of both the portfolio and the benchmark over time.
2. Scatter plot indicating the annualized volatility and the last cumulative return of both the portfolio
and the benchmark, colored by their respective Sharpe Ratios.
Notes:
- The function assumes that 'numpy' and 'plotly.graph_objects' are imported as 'np' and 'go' respectively.
- The function also utilizes 'plotly.subplots.make_subplots' for creating subplots.
- The risk-free rate is assumed to be 1% per annum for Sharpe Ratio calculation.
"""
# Computing the cumulative returns for the portfolio and the benchmark
portfolio_cumsum = (((1 + port_returns).cumprod() - 1) * 100).round(2)
benchmark_cumsum = (((1 + benchmark_returns).cumprod() - 1) * 100).round(2)
# Computing the annualized volatility for the portfolio and the benchmark
port_vol = ((port_returns.std() * np.sqrt(252)) * 100).round(2)
benchmark_vol = ((benchmark_returns.std() * np.sqrt(252)) * 100).round(2)
# Computing Sharpe Ratio for the portfolio and the benchmark
excess_port_returns = port_returns - 0.01 / 252
port_sharpe = (excess_port_returns.mean() / port_returns.std() * np.sqrt(252)).round(2)
exces_benchmark_returns = benchmark_returns - 0.01 / 252
benchmark_sharpe = (exces_benchmark_returns.mean() / benchmark_returns.std() * np.sqrt(252)).round(2)
# Creating a subplot to compare portfolio performance with the benchmark
fig2 = make_subplots(rows = 1, cols = 2, horizontal_spacing=0.25,
column_titles=['Cumulative Returns', 'Portfolio Risk-Reward'],
column_widths=[.55, .45],
shared_xaxes=False, shared_yaxes=False)
# Adding the cumulative returns for the portfolio
fig2.add_trace(go.Scatter(x=portfolio_cumsum.index,
y = portfolio_cumsum,
mode = 'lines', name = 'Portfolio', showlegend=False,
hovertemplate = '%{y:.2f}%'),
row=1,col=1)
# Adding the cumulative returns for the benchmark
fig2.add_trace(go.Scatter(x=benchmark_cumsum.index,
y = benchmark_cumsum,
mode = 'lines', name = 'Benchmark', showlegend=False,
hovertemplate = '%{y:.2f}%'),
row=1,col=1)
# Creating risk-reward plot for the benchmark and the portfolio
fig2.add_trace(go.Scatter(x = [port_vol, benchmark_vol], y = [portfolio_cumsum.iloc[-1], benchmark_cumsum.iloc[-1]],
mode = 'markers+text',
marker=dict(size = 75,
color = [port_sharpe, benchmark_sharpe],
colorscale='Bluered_r',
colorbar=dict(title='Sharpe Ratio'),
showscale=True),
name = 'Returns',
text=['Portfolio', 'Benchmark'], textposition='middle center',
textfont=dict(color='white'),
hovertemplate = '%{y:.2f}%
Annualized Volatility: %{x:.2f}%
Sharpe Ratio: %{marker.color:.2f}',
showlegend=False),
row = 1, col = 2)
# Configuring layout
fig2.update_layout(title={
'text': f'Portfolio vs Benchmark',
'font': {'size': 24}
},
template = 'plotly_white',
height = 650, width = 1250,
hovermode = 'x unified',
#legend_x=.45,
#legend_y=.5
)
fig2.update_yaxes(title_text='Cumulative Returns (%)', col=1)
fig2.update_yaxes(title_text='Cumulative Returns (%)', col = 2)
fig2.update_xaxes(title_text = 'Date', col = 1)
fig2.update_xaxes(title_text = 'Annualized Volatility (%)', col =2)
return fig2 # Returning subplots
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
def portfolio_returns(tickers_and_values, start_date, end_date, benchmark):
"""
This function downloads historical stock data, calculates the weighted returns to build a portfolio,
and compares these returns to a benchmark.
It also displays the portfolio allocation and the performance of the portfolio against the benchmark.
Parameters:
- tickers_and_values (dict): A dictionary where keys are ticker symbols (str) and values are the current
amounts (float) invested in each ticker.
- start_date (str): The start date for the historical data in the format 'YYYY-MM-DD'.
- end_date (str): The end date for the historical data in the format 'YYYY-MM-DD'.
- benchmark (str): The ticker symbol for the benchmark against which to compare the portfolio's performance.
Returns:
- Displays three plots:
1. A pie chart showing the portfolio allocation by ticker.
2. A plot to analyze historical returns and volatility of each security
in the portfolio. (Not plotted if portfolio only has one security)
2. A comparison between portfolio returns and volatility against the benchmark over the specified period.
"""
def download_with_retry(tickers, start, end, auto_adjust=False, max_retries=3, delay=1):
"""Helper function to download data with retries"""
for attempt in range(max_retries):
try:
if isinstance(tickers, list):
# For multiple tickers
df = yf.download(tickers, start=start, end=end, auto_adjust=auto_adjust, progress=False)
else:
# For single ticker
ticker_obj = yf.Ticker(tickers)
df = ticker_obj.history(start=start, end=end, auto_adjust=auto_adjust)
if df.empty:
if attempt == max_retries - 1:
raise ValueError(f"No data downloaded for {tickers}")
time.sleep(delay)
continue
return df
except (RequestException, JSONDecodeError, ValueError) as e:
if attempt == max_retries - 1:
raise ValueError(f"Failed to download data after {max_retries} attempts: {str(e)}")
time.sleep(delay)
return None
def get_price_data(df, ticker=None):
"""Helper function to extract price data from the dataframe"""
if isinstance(df.columns, pd.MultiIndex):
if ticker is None:
# For portfolio data
if 'Adj Close' in df.columns:
return df['Adj Close']
elif 'Close' in df.columns:
return df['Close']
else:
raise ValueError("No price data found in the dataframe")
else:
# For individual ticker
if 'Adj Close' in df.columns and ticker in df['Adj Close'].columns:
return df['Adj Close'][ticker]
elif 'Close' in df.columns and ticker in df['Close'].columns:
return df['Close'][ticker]
else:
raise ValueError(f"No price data found for ticker {ticker}")
else:
# For single ticker dataframe
if 'Adj Close' in df.columns:
return df['Adj Close']
elif 'Close' in df.columns:
return df['Close']
else:
raise ValueError("No price data found in the dataframe")
try:
# Validate inputs
if not tickers_and_values:
return "error", "No tickers provided"
if not benchmark:
return "error", "No benchmark ticker provided"
# Obtaining tickers data with yfinance
df = download_with_retry(list(tickers_and_values.keys()), start_date, end_date, auto_adjust=False)
if df is None:
return "error", "Failed to download portfolio data"
# Checking if there is data available in the given date range
if isinstance(df.columns, pd.MultiIndex):
missing_data_tickers = []
for ticker in tickers_and_values.keys():
try:
price_data = get_price_data(df, ticker)
first_valid_index = price_data.first_valid_index()
if first_valid_index is None or first_valid_index.strftime('%Y-%m-%d') > start_date:
missing_data_tickers.append(ticker)
except ValueError:
missing_data_tickers.append(ticker)
if missing_data_tickers:
error_message = f"No data available for the following tickers starting from {start_date}: {', '.join(missing_data_tickers)}"
return "error", error_message
else:
# For a single ticker, simply check the first valid index
try:
price_data = get_price_data(df)
first_valid_index = price_data.first_valid_index()
if first_valid_index is None or first_valid_index.strftime('%Y-%m-%d') > start_date:
error_message = f"No data available for the ticker starting from {start_date}"
return "error", error_message
except ValueError as e:
return "error", str(e)
# Calculating portfolio value
total_portfolio_value = sum(tickers_and_values.values())
# Calculating the weights for each security in the portfolio
tickers_weights = {ticker: value / total_portfolio_value for ticker, value in tickers_and_values.items()}
# Getting price data for portfolio
try:
if isinstance(df.columns, pd.MultiIndex):
df = get_price_data(df)
else:
df = get_price_data(df)
except ValueError as e:
return "error", str(e)
# Checking if there are more than just one security in the portfolio
if len(tickers_weights) > 1:
weights = list(tickers_weights.values()) # Obtaining weights
weighted_returns = df.pct_change().mul(weights, axis = 1) # Computed weighted returns
port_returns = weighted_returns.sum(axis=1) # Sum weighted returns to build portfolio returns
# If there is only one security in the portfolio...
else:
port_returns = df.pct_change() # Computing returns without weights
# Obtaining benchmark data with yfinance using Ticker object for more reliable data
try:
benchmark_df = download_with_retry(benchmark, start_date, end_date, auto_adjust=False, max_retries=5, delay=2)
if benchmark_df is None or benchmark_df.empty:
return "error", f"Failed to download data for benchmark {benchmark}"
# Getting price data for benchmark
benchmark_df = get_price_data(benchmark_df)
if benchmark_df.empty:
return "error", f"No price data available for benchmark {benchmark}"
# Validate benchmark data
if benchmark_df.isna().all():
return "error", f"All benchmark data is NaN for {benchmark}"
# Computing benchmark returns
benchmark_returns = benchmark_df.pct_change()
# Additional validation for benchmark returns
if benchmark_returns.isna().all():
return "error", f"Could not compute returns for benchmark {benchmark}"
except Exception as e:
return "error", f"Error processing benchmark data: {str(e)}"
# Plotting a pie plot
fig = go.Figure(data=[go.Pie(
labels=list(tickers_weights.keys()), # Obtaining tickers
values=list(tickers_weights.values()), # Obtaining weights
hoverinfo='label+percent',
textinfo='label+percent',
hole=.65,
marker=dict(colors=px.colors.qualitative.G10)
)])
# Defining layout
fig.update_layout(title={
'text': 'Portfolio Allocation',
'font': {'size': 24}
}, height=550, width=1250)
# Running function to compare portfolio and benchmark
fig2 = portfolio_vs_benchmark(port_returns, benchmark_returns)
# If we have more than one security in the portfolio,
# we run function to evaluate each security individually
fig1 = None
if len(tickers_weights) > 1:
fig1 = perform_portfolio_analysis(df, tickers_weights)
return "success", (fig, fig1, fig2)
except Exception as e:
error_message = f"An error occurred while processing the data: {str(e)}"
return "error", error_message