Delete plots.py

plots.py

@@ -1,212 +0,0 @@
-import pandas as pd
-import seaborn as sns
-import streamlit as st
-import matplotlib.pyplot as plt
-import numpy as np
-import altair as alt
-
-def beta(stock_df, choices):
-    symbols, weights, investment = choices.values()
-    tickers = symbols
-    tickers.append('sp500')
-    #print(tickers)
-    quantity = weights
-    selected_stocks = stock_df[tickers]
-    # calculating daily return
-    # loops through each stocks
-    # loops through each row belonging to the stock
-    # calculates the percentage change from previous day
-    # sets the value of first row to zero since there is no previous value
-    df_stocks = selected_stocks.copy()
-
-    for i in selected_stocks.columns[1:]:
-        for j in range(1, len(selected_stocks)):
-            df_stocks[i][j] = ((selected_stocks[i][j] - selected_stocks[i][j - 1]) / selected_stocks[i][j - 1]) * 100
-        df_stocks[i][0] = 0
-    # calculate Beta and alpha for a single stock
-    # used sp500 as a benchmark
-    # used polyfit to calculate beta
-    beta_list = []
-    alpha_list = []
-    stocks_daily_return = df_stocks
-    for i in stocks_daily_return.columns:
-        if i != 'Date' and i != 'sp500':
-            # stocks_daily_return.plot(kind = 'scatter', x = 'A', y = i)
-            b, a = np.polyfit(stocks_daily_return['sp500'], stocks_daily_return[i], 1)
-            # plt.plot(stocks_daily_return['sp500'], b * stocks_daily_return['sp500'] + a, '-', color = 'r')
-            beta_list.append(round(b, 2))
-            alpha_list.append(round(a, 2))
-            # plt.show()
-    # Formats the results
-    symbols.remove('sp500')
-    beta = {'Assets': symbols, 'Beta': beta_list}
-    alpha = {'Assets': symbols, 'Alpha': alpha_list}
-    # Creates a header for streamlit
-    st.subheader('Beta and Alpha of Assets Compared to S&P500 index')
-    col1, col2 = st.columns(2)
-
-    with col1:
-        st.dataframe(beta)
-    with col2:
-        st.dataframe(alpha)
-
-
-def ER(stock_df, choices):
-    symbols, weights, investment = choices.values()
-    symbols_ =symbols
-    tickers = symbols
-    tickers.append('sp500')
-    #print(tickers)
-    quantity = weights
-    selected_stocks = stock_df[tickers]
-    # calculating daily return
-    # loops through each stocks
-    # loops through each row belonging to the stock
-    # calculates the percentage change from previous day
-    # sets the value of first row to zero since there is no previous value
-    df_stocks = selected_stocks.copy()
-
-    for i in selected_stocks.columns[1:]:
-        for j in range(1, len(selected_stocks)):
-            df_stocks[i][j] = ((selected_stocks[i][j] - selected_stocks[i][j - 1]) / selected_stocks[i][j - 1]) * 100
-        df_stocks[i][0] = 0
-    beta = {}
-    alpha = {}
-    stocks_daily_return = df_stocks
-    # print(df_stocks)
-
-    for i in stocks_daily_return.columns:
-        if i != 'Date' and i != 'sp500':
-            # stocks_daily_return.plot(kind = 'scatter', x = 'A', y = i)
-            b, a = np.polyfit(stocks_daily_return['sp500'], stocks_daily_return[i], 1)
-            # plt.plot(stocks_daily_return['sp500'], b * stocks_daily_return['sp500'] + a, '-', color = 'r')
-            beta[i] = round(b, 2)
-            alpha[i] = round(a, 2)
-            # plt.show()
-
-    # calculating camp for a stock
-    keys = list(beta.keys())
-    ER_ = []
-    # rf = 0 assuming risk-free rate of 0
-    rf = 0
-    # rm - annualize retun
-    rm = stocks_daily_return['sp500'].mean() * 252
-    for i in keys:
-        ER_.append( round(rf + (beta[i] * (rm - rf)), 2))
-
-    #for i in keys:
-    #    print('Expected Return based on CAPM for {} is {}%'.format(i, ER_[i]))
-    #print(ER)
-    symbols.remove('sp500')
-    st.subheader('Expected Annual Return Based on CAPM Model')
-
-    Expected_return = {'Assets': symbols, 'Expected Annual Return': ER_}
-    # Creates a header for streamlit
-    st.dataframe(Expected_return)
-
-    
-    # calculate expected return for the portfolio
-    # portfolio weights assume equal
-    portfolio_weights = []
-    current_cash_value = 0
-    total_portfolio_value = 0
-    cash_value_stocks =[]
-    for i in range(len(tickers) ):
-        stocks_name = tickers[i]
-        current_cash_value = selected_stocks[stocks_name].iloc[-1]
-        stocks_quantity = quantity[i]
-        cash_value = stocks_quantity * current_cash_value
-        cash_value_stocks.append(cash_value)
-        total_portfolio_value += cash_value
-        portfolio_weights.append(cash_value)
-    #print(portfolio_weights)
-    portfolio_weights = (portfolio_weights / total_portfolio_value)*100
-    ER_portfolio= []
-    ER_portfolio = sum(list(ER_) * portfolio_weights)/100
-    print('aaa',ER_portfolio)
-
-    st.subheader('Expected Portfolio Return Based on CAPM Model')
-    # Creates a header for streamlit
-    st.write('Expected Portfolio Return is:', ER_portfolio)
-    return beta, cash_value_stocks
-
-
-
-def basic_portfolio(stock_df):
-    """Uses the stock dataframe to graph the normalized historical cumulative returns of each asset.
-    """
-    # Calculates the daily returns of the inputted dataframe
-    daily_return = stock_df.dropna().pct_change()
-    # Calculates the cumulative return of the previously calculated daily return
-    cumulative_return = (1 + daily_return).cumprod()
-
-    # Creates the title for streamlit
-    st.subheader('Portfolio Historical Normalized Cumulative Returns')
-    # Graphs the cumulative returns
-    st.line_chart(cumulative_return)
-
-
-def display_heat_map(stock_df):
-    """Uses the stock dataframe to calculate the correlations between the different assets and display them as a heatmap.
-    """
-    # Calcuilates the correlation of the assets in the portfolio
-    price_correlation = stock_df.corr()
-
-    # Creates the title for streamlit
-    st.subheader('Heatmap Showing Correlation Of Assets')
-    # Generates a figure for the heatmap
-    fig, ax = plt.subplots()
-    sns.heatmap(price_correlation, ax=ax)
-    # Displays the heatmap on streamlit
-    st.write(fig)
-    # Creates a header for the correlation data
-    st.subheader('Correlation Data')
-    # Displays the correlation data on streamlit
-    st.dataframe(price_correlation)
-
-
-#def display_portfolio_return(stock_df, choices):
-    """Uses the stock dataframe and the chosen weights from choices to calculate and graph the historical cumulative portfolio return.
-    """
-#    symbols, weights, investment = choices.values()
-
-    # Calculates the daily percentage returns of the 
-#    daily_returns = stock_df.pct_change().dropna()
-    # Applies the weights of each asset to the portfolio
-#    portfolio_returns = daily_returns.dot(weights)
-    # Calculates the cumulative weighted portfolio return
-#    cumulative_returns = (1 + portfolio_returns).cumprod()
-    # Calculates the cumulative profit using the cumulative portfolio return
-#    cumulative_profit = investment * cumulative_returns
-
-    # Graphs the result, and displays it with a header on streamlit
-#    st.subheader('Portfolio Historical Cumulative Returns Based On Inputs!')
-#    st.line_chart(cumulative_profit)
-    
-def buble_interactive(stock_df,choices):
-    import plotly.express as px
-    symbols, weights, investment = choices.values()
-    beta,cash_value_weights  = ER(stock_df,choices)
-    my_list = []
-    for i in beta.values():
-        my_list.append(i)
-    
-    df_final =pd.DataFrame()
-    df_final['ticker'] = symbols
-    df_final['quantities'] = weights
-    df_final['cash_value']  =cash_value_weights
-    df_final['Beta'] = my_list
-   
-    fig = px.scatter(
-    df_final,
-    x="quantities",
-    y="Beta",
-    size="cash_value",
-    #color="continent",
-    hover_name="ticker",
-    log_x=True,
-    size_max=60,
-    )
-    fig.update_layout(title="Beta ----write something")
-    # -- Input the Plotly chart to the Streamlit interface
-    st.plotly_chart(fig, use_container_width=True)