Upload 3 files

.gitattributes

@@ -32,3 +32,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data_and_sp500.csv filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,127 @@
+import streamlit as st
+from datetime import date, timedelta
+#from rest_api.fetch_data import (get_symbol_data)
+import pandas as pd
+from plots import (
+    beta,
+    basic_portfolio,
+    #display_portfolio_return,
+    display_heat_map,
+    ER,
+    buble_interactive
+)
+
+def load_heading():
+    """The function that displays the heading.
+        Provides instructions to the user
+    """
+    with st.container():
+        st.title('Dataminers')
+        header = st.subheader('This App performs historical portfolio analysis and future analysis ')
+        st.subheader('Please read the instructions carefully and enjoy!')
+        # st.text('This is some text.')
+
+
+def get_choices():
+    """Prompts the dialog to get the All Choices.
+    Returns:
+        An object of choices and an object of combined dataframes.
+    """
+    choices = {}
+
+    tickers = st.sidebar.text_input('Enter 4 stock symbols.', 'GOOG,A,AA,AMD')
+
+    # Set the weights
+    weights_str = st.sidebar.text_input('Enter The Investment Quantities', '50,30,25,25')
+    # Set Initial Investment
+    investment = st.sidebar.number_input('Enter The Initial Investment', min_value=5000, max_value=25000, value=5000)
+
+    # Every form must have a submit button.
+    submitted = st.sidebar.button("Submit")
+
+    symbols = []
+    reset = False
+
+    # Reusable Error Button DRY!
+    #def reset_app(error):
+    #    st.sidebar.write(f"{error}!")
+    #    st.sidebar.write(f"Check The Syntax")
+    #    reset = st.sidebar.button("RESET APP")
+
+    if submitted:
+        # convert  strings to lists
+        tickers_list = tickers.split(",")
+        weights_list = weights_str.split(",")
+        #crypto_symbols_list = crypto_symbols.split(",")
+        # Create the Symbols List
+        symbols.extend(tickers_list)
+        #symbols.extend(crypto_symbols_list)
+        # Convert Weights To Decimals
+        weights = []
+        for item in weights_list:
+            weights.append(float(item))
+
+        if reset:
+        #    # Clears all singleton caches:
+            tickers = st.sidebar.selectbox('Enter 11 stock symbols.', ('GOOG','D','AAP','BLK'))
+        #    crypto_symbols = st.sidebar.text_input('Enter 2 crypto symbols only as below', 'BTC-USD,ETH-USD')
+            weights_str = st.sidebar.text_input('Enter The Investment Weights', '0.3,0.3 ,0.3')
+
+            st.experimental_singleton.clear()
+
+
+        else:
+            # Submit an object with choices
+            choices = {
+
+                'symbols': symbols,
+                'weights': weights,
+                'investment': investment
+
+            }
+            # Load combined_df
+            data = pd.read_csv('data_and_sp500.csv')
+            combined_df = data[tickers_list]
+            # return object of objects
+            return {
+                'choices': choices,
+                'combined_df': combined_df,
+                'data': data
+            }
+
+
+def run():
+    """The main function for running the script."""
+
+    load_heading()
+    choices = get_choices()
+    if choices:
+        st.success('''** Selected Tickers **''')     
+        buble_interactive(choices['data'],choices['choices'])
+        st.header('Tickers Beta')
+        """
+        The Capital Asset Pricing Model (CAPM) utilizes a formula to enable the application to calculate
+risk, return, and variability of return with respect to a benchmark. The application uses this
+benchmark, currently S&P 500 annual rate of return, to calculate the return of a stock using
+Figure 2 in Appendix A. Elements such as beta can be calculated using the formula in Appendix
+A Figure 1. The beta variable will serve as a variable to be used for calculating the variability of
+the stock with respect to the benchmark. This variability factor will prove useful for a variety of
+calculations such as understanding market risk and return. If the beta is equal to 1.0, the stock
+price is correlated with the market. When beta is smaller than 1.0, the stock is less volatile than
+the market. If beta is greater than 1.0, the stock is more volatile than the market.
+The CAPM model was run for 9 stocks, using 10-year daily historical data for initial test analysis.
+With this initial analysis, beta was calculated to determine the stock’s risk by measuring the
+price changes to the benchmark. By using CAPM model, annual expected return and portfolio
+return is calculated. The model results can be found in Appendix A.
+"""
+        beta(choices['data'], choices['choices'])
+        ER(choices['data'], choices['choices'])
+        basic_portfolio(choices['combined_df'])
+        display_heat_map(choices['combined_df'])
+        #display_portfolio_return(choices['combined_df'], choices['choices'])
+       
+        
+
+if __name__ == "__main__":
+    run()
+

data_and_sp500.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb09e57e52edd4e875610fe2ed494af095e682ff26af6f6f7d33bc88b2771e98
+size 18857073

plots.py

@@ -0,0 +1,212 @@
+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)