Create app.py

app.py

@@ -0,0 +1,1410 @@
+import streamlit as st
+import requests
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime
+
+# Set page configuration
+st.set_page_config(page_title="Institutional Investor Portfolios", layout="wide")
+
+# Global API key
+API_KEY = "b431ec171262073909ebf8c0c4afba71"
+
+# Initialize Session State for Portfolio Allocation
+if 'portfolio_allocation_data' not in st.session_state:
+    st.session_state.portfolio_allocation_data = None
+if 'portfolio_allocation_params' not in st.session_state:
+    st.session_state.portfolio_allocation_params = {}
+
+# Initialize Session State for Investor Performance
+if 'investor_performance_data' not in st.session_state:
+    st.session_state.investor_performance_data = None
+if 'investor_performance_params' not in st.session_state:
+    st.session_state.investor_performance_params = {}
+
+# Initialize Session State for Symbol Ownership
+if 'symbol_ownership_data' not in st.session_state:
+    st.session_state.symbol_ownership_data = None
+if 'symbol_ownership_params' not in st.session_state:
+    st.session_state.symbol_ownership_params = {}
+
+# Function for Page 1: CIK List
+def page1():
+    st.title("CIK and Name Combinations")
+    st.markdown("""
+    **Description:**  
+    Fetch and display the list of Central Index Key (CIK). CIK is a unique identifier assigned by the SEC to entities that file disclosures.
+    """)
+
+    with st.spinner("Fetching CIK and Name combinations..."):
+        cik_name_df = fetch_cik_name_combinations()
+        if not cik_name_df.empty:
+            st.success("Data retrieved successfully!")
+            st.dataframe(cik_name_df, use_container_width=True, height=800)
+            
+            # Provide download option
+            csv = cik_name_df.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label="Download Data as CSV",
+                data=csv,
+                file_name='cik_name_combinations.csv',
+                mime='text/csv',
+            )
+        else:
+            st.error("No data retrieved.")
+
+# Function to fetch CIK and name combinations
+@st.cache_data
+def fetch_cik_name_combinations():
+    """
+    Fetches a list of CIK and name combinations from the API.
+
+    Returns:
+        pd.DataFrame: A DataFrame containing CIK and name pairs.
+    """
+    url = f"https://financialmodelingprep.com/api/v4/institutional-ownership/list?apikey={API_KEY}"
+    try:
+        response = requests.get(url)
+        if response.status_code == 200:
+            data = response.json()
+            df = pd.DataFrame(data)
+            if not df.empty and 'cik' in df.columns and 'name' in df.columns:
+                df = df[['cik', 'name']]
+                return df
+            else:
+                return pd.DataFrame()
+        else:
+            st.error(f"Error fetching data: {response.status_code}, {response.text}")
+            return pd.DataFrame()
+    except Exception as e:
+        st.error(f"An exception occurred: {e}")
+        return pd.DataFrame()
+
+# Function for Page 2: Portfolio Allocation
+def page2():
+    st.title("Portfolio Allocation Over Time")
+    st.markdown("""
+    **Description:**  
+    Fetch and visualize portfolio allocation data over time for a specific CIK. Enter the CIK and specify a start date to analyze the portfolio's composition.
+    """)
+
+    # Sidebar Inputs within an Expander
+    with st.sidebar.expander("Portfolio Allocation Inputs", expanded=True):
+        cik_input = st.text_input("Enter CIK", value="0001067983", help="Enter the Central Index Key (CIK) of the institutional investor.")
+        start_date = st.date_input("Select Start Date", value=datetime(2021, 9, 30), help="Choose the start date for fetching portfolio allocation data.")
+        top_n = st.number_input("Top N Groups", min_value=1, max_value=100, value=10, step=1, help="Select the number of top groups to display in trend charts.")
+    
+    run_button = st.sidebar.button("Run")
+
+    if run_button or (st.session_state.portfolio_allocation_params.get('cik') == cik_input and
+                      st.session_state.portfolio_allocation_params.get('start_date') == start_date.strftime("%Y-%m-%d") and
+                      st.session_state.portfolio_allocation_params.get('top_n') == top_n):
+        # Update Session State with current parameters
+        st.session_state.portfolio_allocation_params = {
+            'cik': cik_input,
+            'start_date': start_date.strftime("%Y-%m-%d"),
+            'top_n': top_n
+        }
+
+        with st.spinner("Fetching and processing portfolio allocation data..."):
+            allocation_data = fetch_data_over_time(cik_input, start_date.strftime("%Y-%m-%d"))
+            if not allocation_data.empty:
+                st.session_state.portfolio_allocation_data = allocation_data
+                st.success("Data retrieved successfully!")
+                
+                # Latest date data for bar charts
+                latest_date = allocation_data["date"].max()
+                latest_data = allocation_data[allocation_data["date"] == latest_date]
+                
+                # Plot bar charts
+                st.subheader(f"Portfolio Allocation by Ticker on {latest_date}")
+                fig1 = plot_bar_chart(latest_data, "symbol", "Weight (%)", "Market Value", height=500)
+                st.plotly_chart(fig1, use_container_width=True)
+                
+                st.subheader(f"Portfolio Allocation by Industry on {latest_date}")
+                fig2 = plot_bar_chart(latest_data, "industryTitle", "Weight (%)", "Market Value", height=700)
+                st.plotly_chart(fig2, use_container_width=True)
+                
+                # Time-series plots for trends
+                st.subheader("Portfolio Allocation Trends by Symbol")
+                st.markdown("""
+                **Explanation:**  
+                This chart shows the trends in portfolio allocation by individual symbols over time. The top N symbols by weight are displayed to highlight the most significant contributors to the portfolio.
+                """)
+                fig3 = plot_allocation_trends(allocation_data, "symbol", st.session_state.portfolio_allocation_params.get('top_n'))
+                st.plotly_chart(fig3, use_container_width=True, height=600)
+                
+                st.subheader("Portfolio Allocation Trends by Industry")
+                st.markdown("""
+                **Explanation:**  
+                This chart illustrates the trends in portfolio allocation across different industries over time. The top N industries by weight are displayed to emphasize the major sectors in the portfolio.
+                """)
+                fig4 = plot_allocation_trends(allocation_data, "industryTitle", st.session_state.portfolio_allocation_params.get('top_n'))
+                st.plotly_chart(fig4, use_container_width=True, height=600)
+                
+                # Transpose data at the bottom
+                st.markdown("---")
+                st.subheader("Transposed Ticker Data")
+                st.markdown("""
+                **Explanation:**  
+                This table presents the portfolio allocation weights and market values for each ticker across different dates. It provides a detailed view of how each stock's weight and market value have evolved over time.
+                """)
+                transposed_ticker_data = transpose_data(allocation_data, "symbol")
+                st.dataframe(transposed_ticker_data, use_container_width=True)
+                
+                st.subheader("Transposed Industry Data")
+                st.markdown("""
+                **Explanation:**  
+                This table displays the portfolio allocation weights and market values for each industry across different dates. It offers insights into the sector-wise distribution and changes in the portfolio.
+                """)
+                transposed_industry_data = transpose_data(allocation_data, "industryTitle")
+                st.dataframe(transposed_industry_data, use_container_width=True)
+            else:
+                st.error("No data found for the specified CIK and date range.")
+
+    # If data exists in session state and parameters match, display it without rerunning
+    elif st.session_state.portfolio_allocation_data and st.session_state.portfolio_allocation_params.get('cik') == cik_input and \
+         st.session_state.portfolio_allocation_params.get('start_date') == start_date.strftime("%Y-%m-%d") and \
+         st.session_state.portfolio_allocation_params.get('top_n') == top_n:
+        
+        allocation_data = st.session_state.portfolio_allocation_data
+
+        st.success("Displaying previously retrieved data.")
+        
+        # Latest date data for bar charts
+        latest_date = allocation_data["date"].max()
+        latest_data = allocation_data[allocation_data["date"] == latest_date]
+        
+        # Plot bar charts
+        st.subheader(f"Portfolio Allocation by Ticker on {latest_date}")
+        fig1 = plot_bar_chart(latest_data, "symbol", "Weight (%)", "Market Value", height=500)
+        st.plotly_chart(fig1, use_container_width=True)
+        
+        st.subheader(f"Portfolio Allocation by Industry on {latest_date}")
+        fig2 = plot_bar_chart(latest_data, "industryTitle", "Weight (%)", "Market Value", height=700)
+        st.plotly_chart(fig2, use_container_width=True)
+        
+        # Time-series plots for trends
+        st.subheader("Portfolio Allocation Trends by Symbol")
+        st.markdown("""
+        **Explanation:**  
+        This chart shows the trends in portfolio allocation by individual symbols over time. The top N symbols by weight are displayed to highlight the most significant contributors to the portfolio.
+        """)
+        fig3 = plot_allocation_trends(allocation_data, "symbol", top_n)
+        st.plotly_chart(fig3, use_container_width=True, height=600)
+        
+        st.subheader("Portfolio Allocation Trends by Industry")
+        st.markdown("""
+        **Explanation:**  
+        This chart illustrates the trends in portfolio allocation across different industries over time. The top N industries by weight are displayed to emphasize the major sectors in the portfolio.
+        """)
+        fig4 = plot_allocation_trends(allocation_data, "industryTitle", top_n)
+        st.plotly_chart(fig4, use_container_width=True, height=600)
+        
+        # Transpose data at the bottom
+        st.markdown("---")
+        st.subheader("Transposed Ticker Data")
+        st.markdown("""
+        **Explanation:**  
+        This table presents the portfolio allocation weights and market values for each ticker across different dates. It provides a detailed view of how each stock's weight and market value have evolved over time.
+        """)
+        transposed_ticker_data = transpose_data(allocation_data, "symbol")
+        st.dataframe(transposed_ticker_data, use_container_width=True)
+        
+        st.subheader("Transposed Industry Data")
+        st.markdown("""
+        **Explanation:**  
+        This table displays the portfolio allocation weights and market values for each industry across different dates. It offers insights into the sector-wise distribution and changes in the portfolio.
+        """)
+        transposed_industry_data = transpose_data(allocation_data, "industryTitle")
+        st.dataframe(transposed_industry_data, use_container_width=True)
+
+# Functions used in Page 2
+@st.cache_data
+def fetch_dates(cik):
+    """
+    Fetches all available quarter-end dates for a specific CIK.
+
+    Args:
+        cik (str): Central Index Key of the institutional investor.
+
+    Returns:
+        list: A list of available quarter-end dates in descending order.
+    """
+    endpoint = f"https://financialmodelingprep.com/api/v4/institutional-ownership/portfolio-date"
+    params = {"cik": cik, "apikey": API_KEY}
+    try:
+        response = requests.get(endpoint, params=params)
+        if response.status_code == 200:
+            dates = sorted([item["date"] for item in response.json()], reverse=True)
+            return dates
+        else:
+            st.error(f"Error fetching dates: {response.status_code}, {response.text}")
+            return []
+    except Exception as e:
+        st.error(f"An exception occurred: {e}")
+        return []
+
+@st.cache_data
+def fetch_portfolio_allocation(cik, date, page=0):
+    """
+    Fetches portfolio allocation for a specific CIK and date from the API.
+
+    Args:
+        cik (str): Central Index Key of the institutional investor.
+        date (str): Quarter-end date in YYYY-MM-DD format.
+        page (int): Page number for large datasets (default is 0).
+
+    Returns:
+        pd.DataFrame: Processed DataFrame containing portfolio allocation.
+    """
+    endpoint = f"https://financialmodelingprep.com/api/v4/institutional-ownership/portfolio-holdings"
+    params = {
+        "cik": cik,
+        "date": date,
+        "page": page,
+        "apikey": API_KEY
+    }
+    try:
+        response = requests.get(endpoint, params=params)
+        if response.status_code == 200:
+            data = response.json()
+            df = pd.DataFrame(data)
+            if not df.empty and all(col in df.columns for col in ["symbol", "industryTitle", "weight", "marketValue"]):
+                df = df[["symbol", "industryTitle", "weight", "marketValue"]]
+                df["weight"] = df["weight"].astype(float)
+                df["marketValue"] = df["marketValue"].astype(float)
+                df["date"] = date
+                return df
+            else:
+                return pd.DataFrame()
+        else:
+            st.error(f"Error fetching allocation: {response.status_code}, {response.text}")
+            return pd.DataFrame()
+    except Exception as e:
+        st.error(f"An exception occurred: {e}")
+        return pd.DataFrame()
+
+def fetch_data_over_time(cik, start_date):
+    """
+    Fetches portfolio allocation data over time starting from the specified date.
+
+    Args:
+        cik (str): Central Index Key of the institutional investor.
+        start_date (str): Start date in YYYY-MM-DD format.
+
+    Returns:
+        pd.DataFrame: Consolidated DataFrame containing portfolio allocation over time.
+    """
+    available_dates = fetch_dates(cik)
+    selected_dates = [date for date in available_dates if date >= start_date]
+    all_data = []
+    
+    for date in selected_dates:
+        # Removed individual fetching messages
+        df = fetch_portfolio_allocation(cik, date)
+        if not df.empty:
+            all_data.append(df)
+    
+    if all_data:
+        return pd.concat(all_data, ignore_index=True)
+    else:
+        st.error("No data found for the specified time range.")
+        return pd.DataFrame()
+
+def transpose_data(df, group_by_column):
+    """
+    Transposes the DataFrame so that dates become columns for weight and market value.
+
+    Args:
+        df (pd.DataFrame): Original DataFrame containing portfolio allocation over time.
+        group_by_column (str): Column to group data by (e.g., "symbol" or "industryTitle").
+
+    Returns:
+        pd.DataFrame: Transposed DataFrame.
+    """
+    pivoted_weight = df.pivot_table(values="weight", index=group_by_column, columns="date", aggfunc="sum", fill_value=0)
+    pivoted_market_value = df.pivot_table(values="marketValue", index=group_by_column, columns="date", aggfunc="sum", fill_value=0)
+    
+    # Reorder columns: weight -> market value -> next weight -> next market value
+    combined = pd.concat([pivoted_weight, pivoted_market_value], axis=1, keys=["Weight", "Market Value"])
+    combined = combined.swaplevel(axis=1).sort_index(axis=1)
+    return combined
+
+def plot_bar_chart(df, group_by_column, weight_title, market_value_title, height=500):
+    """
+    Plots a bar chart for portfolio allocation using Plotly.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing portfolio allocation data.
+        group_by_column (str): Column to group data by (e.g., "symbol" or "industryTitle").
+        weight_title (str): Title for the weight axis.
+        market_value_title (str): Title for the market value.
+        height (int): Height of the plot in pixels.
+
+    Returns:
+        plotly.graph_objects.Figure: Plotly figure object.
+    """
+    # Ensure data only corresponds to the latest date and aggregate by the group column
+    latest_date = df["date"].max()
+    filtered_df = df[df["date"] == latest_date].groupby(group_by_column, as_index=False).sum()
+    
+    # Sort the data by weight in descending order
+    filtered_df = filtered_df.sort_values(by="weight", ascending=False)
+    
+    # Format market values for display
+    filtered_df["marketValueFormatted"] = filtered_df["marketValue"].apply(format_market_value)
+    
+    # Create bar chart
+    fig = go.Figure()
+    fig.add_trace(go.Bar(
+        x=filtered_df[group_by_column],
+        y=filtered_df["weight"],
+        text=[f"{w:.1f}%<br>{mv}" for w, mv in zip(filtered_df["weight"], filtered_df["marketValueFormatted"])],
+        textposition="outside",
+        texttemplate="%{text}",
+        marker=dict(color="teal"),
+        textfont=dict(size=14),  # Makes the labels larger
+        cliponaxis=False  # Ensures labels aren't clipped
+    ))
+    fig.update_layout(
+        title=f"Portfolio Allocation by {group_by_column.capitalize()} on {latest_date}",
+        xaxis_title=group_by_column.capitalize(),
+        yaxis_title=weight_title,
+        xaxis_tickangle=45,  # Make labels vertical
+        showlegend=False,
+        height=height
+    )
+    fig.update_traces(
+        textfont_size=12,  # Increase font size
+        cliponaxis=False  # Ensure text doesn't get clipped
+    )
+    return fig
+
+def plot_allocation_trends(df, group_by_column, top_n=10):
+    """
+    Plots trends for portfolio allocation over time using Plotly.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing portfolio allocation data over time.
+        group_by_column (str): Column to group data by (e.g., "symbol" or "industryTitle").
+        top_n (int): Number of top contributors to show in the chart.
+
+    Returns:
+        plotly.express.Figure: Plotly figure object.
+    """
+    # Group and aggregate data by group_by_column and date
+    aggregated_df = df.groupby([group_by_column, "date"], as_index=False).sum()
+
+    # Summarize total weight for sorting
+    total_weight = aggregated_df.groupby(group_by_column)["weight"].sum().sort_values(ascending=False)
+    top_groups = total_weight.head(top_n).index
+
+    # Filter data to include only the top_n groups
+    filtered_df = aggregated_df[aggregated_df[group_by_column].isin(top_groups)]
+    filtered_df["marketValueFormatted"] = filtered_df["marketValue"].apply(format_market_value)
+    
+    # Create the Plotly line chart
+    fig = px.line(
+        filtered_df,
+        x="date",
+        y="weight",
+        color=group_by_column,
+        title=f"Portfolio Allocation Trends by {group_by_column.capitalize()}",
+        labels={"weight": "Weight (%)", "date": "Date"},
+        markers=True,
+        hover_data={
+            group_by_column: True,
+            "weight": ":.2f",  # Weight with 2 decimals
+            "marketValueFormatted": True  # Show market value in hover
+        }
+    )
+    fig.update_layout(
+        legend_title=group_by_column.capitalize(),
+        xaxis_title="Date",
+        yaxis_title="Weight (%)",
+        hovermode="closest",
+        height=600
+    )
+    return fig
+
+def format_market_value(value):
+    """
+    Formats a market value into billions, millions, or thousands with appropriate units.
+
+    Args:
+        value (float): Market value in absolute terms.
+
+    Returns:
+        str: Formatted market value as a string with units.
+    """
+    if value >= 1e9:
+        return f"{value / 1e9:.1f}B"
+    elif value >= 1e6:
+        return f"{value / 1e6:.1f}M"
+    elif value >= 1e3:
+        return f"{value / 1e3:.1f}K"
+    else:
+        return f"{value:.1f}"
+
+# Function for Page 3: Investor Performance
+def page3():
+    st.title("Investor Performance")
+    st.markdown("""
+    **Description:**  
+    Fetch and visualize various performance metrics for a specific institutional investor identified by their CIK. Analyze portfolio value, market value changes, performance relative to benchmarks, turnover metrics, and more.
+    """)
+
+    # Sidebar Inputs within an Expander
+    with st.sidebar.expander("Investor Performance Inputs", expanded=True):
+        cik_input = st.text_input("Enter CIK", value="0001067983", help="Enter the Central Index Key (CIK) of the institutional investor.")
+    
+    run_button = st.sidebar.button("Run")
+
+    if run_button or (st.session_state.investor_performance_params.get('cik') == cik_input):
+        # Update Session State with current parameters
+        st.session_state.investor_performance_params = {
+            'cik': cik_input
+        }
+
+        with st.spinner("Fetching and processing investor performance data..."):
+            data = fetch_investor_performance(cik_input)
+            if not data.empty:
+                st.session_state.investor_performance_data = data
+                st.success("Data retrieved successfully!")
+                st.dataframe(data, use_container_width=True)
+                
+                # Ensure the data is sorted by date
+                data["date"] = pd.to_datetime(data["date"])
+                data = data.sort_values(by="date")
+                
+                # Plotting
+                st.subheader("Portfolio Value and Change in Market Value (%)")
+                st.markdown("""
+                **Explanation:**  
+                This chart displays the portfolio's total market value over time alongside the percentage change in market value. It helps in understanding the growth or decline of the portfolio's value.
+                """)
+                fig1 = plot_portfolio_value_and_change(data)
+                st.plotly_chart(fig1, use_container_width=True)
+                
+                st.subheader("Performance and Relative Performance to S&P 500")
+                st.markdown("""
+                **Explanation:**  
+                This chart compares the portfolio's performance against the S&P 500 benchmark. It shows how well the portfolio is performing relative to the broader market.
+                """)
+                fig2 = plot_performance_and_relative(data)
+                st.plotly_chart(fig2, use_container_width=True)
+                
+                st.subheader("Portfolio Turnover Metrics")
+                st.markdown("""
+                **Explanation:**  
+                This chart illustrates the portfolio's turnover rate, including buy and sell activities. Turnover metrics provide insight into the trading frequency and strategy.
+                """)
+                fig3 = plot_turnover_metrics(data)
+                st.plotly_chart(fig3, use_container_width=True)
+                
+                st.subheader("Cumulative Performance Over Time")
+                st.markdown("""
+                **Explanation:**  
+                This chart shows the cumulative performance of the portfolio over different time horizons (1-year, 3-year, 5-year, and since inception). It highlights long-term growth trends.
+                """)
+                fig4 = plot_cumulative_performance(data)
+                st.plotly_chart(fig4, use_container_width=True)
+                
+                st.subheader("Holding Periods")
+                st.markdown("""
+                **Explanation:**  
+                This chart depicts the average holding periods for the portfolio and its top holdings. Holding periods indicate the investment duration and strategy stability.
+                """)
+                fig5 = plot_holding_periods(data)
+                st.plotly_chart(fig5, use_container_width=True)
+                
+                st.subheader("Portfolio Activity")
+                st.markdown("""
+                **Explanation:**  
+                This chart displays portfolio size changes and the number of securities added or removed. It provides an overview of portfolio expansion or contraction.
+                """)
+                fig6 = plot_portfolio_activity(data)
+                st.plotly_chart(fig6, use_container_width=True)
+                
+                st.subheader("Market Value and Securities Count")
+                st.markdown("""
+                **Explanation:**  
+                This chart compares the portfolio's total market value against the number of securities held. It helps in understanding the diversification and valuation aspects of the portfolio.
+                """)
+                fig7 = plot_market_value_and_securities(data)
+                st.plotly_chart(fig7, use_container_width=True)
+            else:
+                st.error("No data found for the specified CIK.")
+
+    # If data exists in session state and parameters match, display it without rerunning
+    elif st.session_state.investor_performance_data and st.session_state.investor_performance_params.get('cik') == cik_input:
+        data = st.session_state.investor_performance_data
+
+        st.success("Displaying previously retrieved data.")
+        st.dataframe(data, use_container_width=True)
+        
+        # Ensure the data is sorted by date
+        data["date"] = pd.to_datetime(data["date"])
+        data = data.sort_values(by="date")
+        
+        # Plotting
+        st.subheader("Portfolio Value and Change in Market Value (%)")
+        st.markdown("""
+        **Explanation:**  
+        This chart displays the portfolio's total market value over time alongside the percentage change in market value. It helps in understanding the growth or decline of the portfolio's value.
+        """)
+        fig1 = plot_portfolio_value_and_change(data)
+        st.plotly_chart(fig1, use_container_width=True)
+        
+        st.subheader("Performance and Relative Performance to S&P 500")
+        st.markdown("""
+        **Explanation:**  
+        This chart compares the portfolio's performance against the S&P 500 benchmark. It shows how well the portfolio is performing relative to the broader market.
+        """)
+        fig2 = plot_performance_and_relative(data)
+        st.plotly_chart(fig2, use_container_width=True)
+        
+        st.subheader("Portfolio Turnover Metrics")
+        st.markdown("""
+        **Explanation:**  
+        This chart illustrates the portfolio's turnover rate, including buy and sell activities. Turnover metrics provide insight into the trading frequency and strategy.
+        """)
+        fig3 = plot_turnover_metrics(data)
+        st.plotly_chart(fig3, use_container_width=True)
+        
+        st.subheader("Cumulative Performance Over Time")
+        st.markdown("""
+        **Explanation:**  
+        This chart shows the cumulative performance of the portfolio over different time horizons (1-year, 3-year, 5-year, and since inception). It highlights long-term growth trends.
+        """)
+        fig4 = plot_cumulative_performance(data)
+        st.plotly_chart(fig4, use_container_width=True)
+        
+        st.subheader("Holding Periods")
+        st.markdown("""
+        **Explanation:**  
+        This chart depicts the average holding periods for the portfolio and its top holdings. Holding periods indicate the investment duration and strategy stability.
+        """)
+        fig5 = plot_holding_periods(data)
+        st.plotly_chart(fig5, use_container_width=True)
+        
+        st.subheader("Portfolio Activity")
+        st.markdown("""
+        **Explanation:**  
+        This chart displays portfolio size changes and the number of securities added or removed. It provides an overview of portfolio expansion or contraction.
+        """)
+        fig6 = plot_portfolio_activity(data)
+        st.plotly_chart(fig6, use_container_width=True)
+        
+        st.subheader("Market Value and Securities Count")
+        st.markdown("""
+        **Explanation:**  
+        This chart compares the portfolio's total market value against the number of securities held. It helps in understanding the diversification and valuation aspects of the portfolio.
+        """)
+        fig7 = plot_market_value_and_securities(data)
+        st.plotly_chart(fig7, use_container_width=True)
+
+# Functions used in Page 3
+@st.cache_data
+def fetch_investor_performance(cik):
+    """
+    Fetches investor performance data from FMP API.
+
+    Args:
+        cik (str): Central Index Key of the institutional investor.
+
+    Returns:
+        pd.DataFrame: DataFrame containing investor performance data.
+    """
+    url = f"https://financialmodelingprep.com/api/v4/institutional-ownership/portfolio-holdings-summary"
+    params = {
+        "cik": cik,
+        "page": 0,
+        "apikey": API_KEY
+    }
+    try:
+        response = requests.get(url, params=params)
+        if response.status_code == 200:
+            data = response.json()
+            df = pd.DataFrame(data)
+            return df
+        else:
+            st.error(f"Failed to fetch data: {response.status_code}")
+            return pd.DataFrame()
+    except Exception as e:
+        st.error(f"An exception occurred: {e}")
+        return pd.DataFrame()
+
+def plot_portfolio_value_and_change(df):
+    """
+    Plots portfolio value and change in market value percentage.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing investor performance data.
+
+    Returns:
+        plotly.graph_objects.Figure: Plotly figure object.
+    """
+    fig = go.Figure()
+
+    # Portfolio Value Line
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["marketValue"], 
+        mode='lines+markers', 
+        name="Portfolio Value",
+        yaxis="y1"
+    ))
+
+    # Change in Market Value Percentage Line
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["changeInMarketValuePercentage"], 
+        mode='lines+markers', 
+        name="Change in Market Value (%)",
+        yaxis="y2"
+    ))
+
+    fig.update_layout(
+        title="Portfolio Value and Change in Market Value (%)",
+        xaxis_title="Date",
+        yaxis=dict(title="Market Value ($)", tickformat="$,.0f"),
+        yaxis2=dict(title="Change in Market Value (%)", overlaying="y", side="right", tickformat=".2f"),
+        legend=dict(title="Metrics"),
+        height=500
+    )
+    return fig
+
+def plot_performance_and_relative(df):
+    """
+    Plots performance and relative performance to S&P 500.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing investor performance data.
+
+    Returns:
+        plotly.graph_objects.Figure: Plotly figure object.
+    """
+    fig = go.Figure()
+
+    # Performance Percentage Line
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["performancePercentage"], 
+        mode='lines+markers', 
+        name="Performance (%)",
+        yaxis="y1"
+    ))
+
+    # Relative Performance Percentage Line
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["performanceRelativeToSP500Percentage"], 
+        mode='lines+markers', 
+        name="Relative Performance to S&P 500 (%)",
+        yaxis="y2"
+    ))
+
+    fig.update_layout(
+        title="Performance and Relative Performance to S&P 500",
+        xaxis_title="Date",
+        yaxis=dict(title="Performance (%)", tickformat=".2f"),
+        yaxis2=dict(title="Relative Performance (%)", overlaying="y", side="right", tickformat=".2f"),
+        legend=dict(title="Metrics"),
+        height=500
+    )
+    return fig
+
+def plot_turnover_metrics(df):
+    """
+    Plots portfolio turnover metrics.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing investor performance data.
+
+    Returns:
+        plotly.graph_objects.Figure: Plotly figure object.
+    """
+    fig = go.Figure()
+
+    # Turnover Line
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["turnover"], 
+        mode='lines+markers', 
+        name="Turnover (%)",
+        yaxis="y1"
+    ))
+
+    # Alternate Turnover Metrics
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["turnoverAlternateSell"], 
+        mode='lines+markers', 
+        name="Turnover (Sell)",
+        yaxis="y2"
+    ))
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["turnoverAlternateBuy"], 
+        mode='lines+markers', 
+        name="Turnover (Buy)",
+        yaxis="y2"
+    ))
+
+    fig.update_layout(
+        title="Portfolio Turnover Metrics",
+        xaxis_title="Date",
+        yaxis=dict(title="Turnover (%)", tickformat=".2f"),
+        yaxis2=dict(title="Turnover (Buy/Sell)", overlaying="y", side="right", tickformat=".2f"),
+        legend=dict(title="Metrics"),
+        height=500
+    )
+    return fig
+
+def plot_cumulative_performance(df):
+    """
+    Plots cumulative performance over time.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing investor performance data.
+
+    Returns:
+        plotly.graph_objects.Figure: Plotly figure object.
+    """
+    fig = go.Figure()
+
+    # Cumulative Performance Percentages
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["performancePercentage1year"], 
+        mode='lines+markers', 
+        name="1-Year Performance (%)",
+        yaxis="y1"
+    ))
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["performancePercentage3year"], 
+        mode='lines+markers', 
+        name="3-Year Performance (%)",
+        yaxis="y1"
+    ))
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["performancePercentage5year"], 
+        mode='lines+markers', 
+        name="5-Year Performance (%)",
+        yaxis="y1"
+    ))
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["performanceSinceInceptionPercentage"], 
+        mode='lines+markers', 
+        name="Since Inception (%)",
+        yaxis="y1"
+    ))
+
+    fig.update_layout(
+        title="Cumulative Performance Over Time",
+        xaxis_title="Date",
+        yaxis=dict(title="Performance (%)", tickformat=".2f"),
+        legend=dict(title="Metrics"),
+        height=500
+    )
+    return fig
+
+def plot_holding_periods(df):
+    """
+    Plots holding periods.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing investor performance data.
+
+    Returns:
+        plotly.graph_objects.Figure: Plotly figure object.
+    """
+    fig = go.Figure()
+
+    # Overall Holding Period
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["averageHoldingPeriod"], 
+        mode='lines+markers', 
+        name="Average Holding Period",
+        yaxis="y1"
+    ))
+
+    # Top Holdings Periods
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["averageHoldingPeriodTop10"], 
+        mode='lines+markers', 
+        name="Top 10 Holding Period",
+        yaxis="y1"
+    ))
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["averageHoldingPeriodTop20"], 
+        mode='lines+markers', 
+        name="Top 20 Holding Period",
+        yaxis="y1"
+    ))
+
+    fig.update_layout(
+        title="Holding Periods",
+        xaxis_title="Date",
+        yaxis=dict(title="Holding Period (Quarters)"),
+        legend=dict(title="Metrics"),
+        height=500
+    )
+    return fig
+
+def plot_portfolio_activity(df):
+    """
+    Plots portfolio activity.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing investor performance data.
+
+    Returns:
+        plotly.graph_objects.Figure: Plotly figure object.
+    """
+    fig = go.Figure()
+
+    # Portfolio Size
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["portfolioSize"], 
+        mode='lines+markers', 
+        name="Portfolio Size",
+        yaxis="y1"
+    ))
+
+    # Securities Added and Removed
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["securitiesAdded"], 
+        mode='lines+markers', 
+        name="Securities Added",
+        yaxis="y2"
+    ))
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["securitiesRemoved"], 
+        mode='lines+markers', 
+        name="Securities Removed",
+        yaxis="y2"
+    ))
+
+    fig.update_layout(
+        title="Portfolio Activity",
+        xaxis_title="Date",
+        yaxis=dict(title="Portfolio Size"),
+        yaxis2=dict(title="Activity (Count)", overlaying="y", side="right"),
+        legend=dict(title="Metrics"),
+        height=500
+    )
+    return fig
+
+def plot_market_value_and_securities(df):
+    """
+    Plots market value and securities count.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing investor performance data.
+
+    Returns:
+        plotly.graph_objects.Figure: Plotly figure object.
+    """
+    fig = go.Figure()
+
+    # Portfolio Value Line
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["marketValue"], 
+        mode='lines+markers', 
+        name="Portfolio Value",
+        yaxis="y1"
+    ))
+
+    # Portfolio Size Line
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["portfolioSize"], 
+        mode='lines+markers', 
+        name="Portfolio Size",
+        yaxis="y2"
+    ))
+
+    fig.update_layout(
+        title="Market Value and Securities Count",
+        xaxis_title="Date",
+        yaxis=dict(title="Market Value ($)", tickformat="$,.0f"),
+        yaxis2=dict(title="Portfolio Size", overlaying="y", side="right"),
+        legend=dict(title="Metrics"),
+        height=500
+    )
+    return fig
+
+# Function to fetch symbol ownership (Page 4)
+@st.cache_data
+def fetch_symbol_ownership(symbol):
+    """
+    Fetches symbol ownership data from FMP API.
+
+    Args:
+        symbol (str): Stock symbol.
+
+    Returns:
+        pd.DataFrame: DataFrame containing symbol ownership data.
+    """
+    url = f"https://financialmodelingprep.com/api/v4/institutional-ownership/symbol-ownership"
+    params = {
+        "symbol": symbol,
+        "includeCurrentQuarter": "true",
+        "apikey": API_KEY
+    }
+    try:
+        response = requests.get(url, params=params)
+        if response.status_code == 200:
+            data = response.json()
+            df = pd.DataFrame(data)
+            return df
+        else:
+            st.error(f"Failed to fetch data: {response.status_code}")
+            return pd.DataFrame()
+    except Exception as e:
+        st.error(f"An exception occurred: {e}")
+        return pd.DataFrame()
+
+# Function for Page 4: Symbol Ownership
+def page4():
+    st.title("Symbol Ownership")
+    st.markdown("""
+    **Description:**  
+    Fetch and visualizes ownership data for a specific stock symbol. Analyze investor counts, ownership percentages, portfolio value changes, positions activity, derivative activity.
+    """)
+
+    # Sidebar Inputs within an Expander
+    with st.sidebar.expander("Symbol Ownership Inputs", expanded=True):
+        symbol = st.text_input("Enter Stock Symbol", value="AAPL", help="Enter the stock symbol you want to analyze, e.g., AAPL for Apple Inc.")
+    
+    run_button = st.sidebar.button("Run")
+
+    if run_button or (st.session_state.symbol_ownership_params.get('symbol') == symbol):
+        # Update Session State with current parameters
+        st.session_state.symbol_ownership_params = {
+            'symbol': symbol
+        }
+
+        with st.spinner("Fetching and processing symbol ownership data..."):
+            data = fetch_symbol_ownership(symbol)
+            if not data.empty:
+                st.session_state.symbol_ownership_data = data
+                st.success("Data retrieved successfully!")
+                st.dataframe(data, use_container_width=True)
+                
+                # Ensure the data is sorted by date
+                data["date"] = pd.to_datetime(data["date"])
+                data = data.sort_values(by="date")
+                
+                # Plotting
+                st.subheader("Investor Count and Ownership Percentage")
+                st.markdown("""
+                **Explanation:**  
+                This chart displays the number of investors holding the stock and the percentage of ownership over time. It provides insights into investor interest and ownership trends.
+                """)
+                fig1 = plot_investor_count_and_ownership(data)
+                st.plotly_chart(fig1, use_container_width=True)
+                
+                st.subheader("Portfolio Value and Ownership Percentage Change")
+                st.markdown("""
+                **Explanation:**  
+                This chart shows the total invested amount and how the ownership percentage has changed over time. It helps in understanding investment growth and shifts in ownership stakes.
+                """)
+                fig2 = plot_portfolio_value_and_change_symbol(data)
+                st.plotly_chart(fig2, use_container_width=True)
+                
+                st.subheader("Positions Activity")
+                st.markdown("""
+                **Explanation:**  
+                This chart illustrates the activity related to positions, including new and closed positions as well as increases and reductions. It reflects the trading dynamics of the stock.
+                """)
+                fig3 = plot_positions_activity_symbol(data)
+                st.plotly_chart(fig3, use_container_width=True)
+                
+                st.subheader("Derivative Activity")
+                st.markdown("""
+                **Explanation:**  
+                This chart displays derivative activities such as total calls and puts, along with the put/call ratio. It provides insights into options trading related to the stock.
+                """)
+                fig4 = plot_derivative_activity_symbol(data)
+                st.plotly_chart(fig4, use_container_width=True)
+                
+                st.subheader("Changes in Metrics")
+                st.markdown("""
+                **Explanation:**  
+                This chart shows the changes in key metrics like the number of 13F shares and total investment. It highlights significant shifts in investment positions.
+                """)
+                fig5 = plot_changes_in_metrics_symbol(data)
+                st.plotly_chart(fig5, use_container_width=True)
+                
+                st.subheader("Ownership Percent and Total Invested")
+                st.markdown("""
+                **Explanation:**  
+                This chart compares the ownership percentage with the total amount invested in the stock. It helps in assessing the investment intensity relative to ownership stake.
+                """)
+                fig6 = plot_ownership_and_investment_symbol(data)
+                st.plotly_chart(fig6, use_container_width=True)
+            else:
+                st.error("No data found for the specified symbol.")
+
+    # If data exists in session state and parameters match, display it without rerunning
+    elif st.session_state.symbol_ownership_data and st.session_state.symbol_ownership_params.get('symbol') == symbol:
+        data = st.session_state.symbol_ownership_data
+
+        st.success("Displaying previously retrieved data.")
+        st.dataframe(data, use_container_width=True)
+        
+        # Ensure the data is sorted by date
+        data["date"] = pd.to_datetime(data["date"])
+        data = data.sort_values(by="date")
+        
+        # Plotting
+        st.subheader("Investor Count and Ownership Percentage")
+        st.markdown("""
+        **Explanation:**  
+        This chart displays the number of investors holding the stock and the percentage of ownership over time. It provides insights into investor interest and ownership trends.
+        """)
+        fig1 = plot_investor_count_and_ownership(data)
+        st.plotly_chart(fig1, use_container_width=True)
+        
+        st.subheader("Portfolio Value and Ownership Percentage Change")
+        st.markdown("""
+        **Explanation:**  
+        This chart shows the total invested amount and how the ownership percentage has changed over time. It helps in understanding investment growth and shifts in ownership stakes.
+        """)
+        fig2 = plot_portfolio_value_and_change_symbol(data)
+        st.plotly_chart(fig2, use_container_width=True)
+        
+        st.subheader("Positions Activity")
+        st.markdown("""
+        **Explanation:**  
+        This chart illustrates the activity related to positions, including new and closed positions as well as increases and reductions. It reflects the trading dynamics of the stock.
+        """)
+        fig3 = plot_positions_activity_symbol(data)
+        st.plotly_chart(fig3, use_container_width=True)
+        
+        st.subheader("Derivative Activity")
+        st.markdown("""
+        **Explanation:**  
+        This chart displays derivative activities such as total calls and puts, along with the put/call ratio. It provides insights into options trading related to the stock.
+        """)
+        fig4 = plot_derivative_activity_symbol(data)
+        st.plotly_chart(fig4, use_container_width=True)
+        
+        st.subheader("Changes in Metrics")
+        st.markdown("""
+        **Explanation:**  
+        This chart shows the changes in key metrics like the number of 13F shares and total investment. It highlights significant shifts in investment positions.
+        """)
+        fig5 = plot_changes_in_metrics_symbol(data)
+        st.plotly_chart(fig5, use_container_width=True)
+        
+        st.subheader("Ownership Percent and Total Invested")
+        st.markdown("""
+        **Explanation:**  
+        This chart compares the ownership percentage with the total amount invested in the stock. It helps in assessing the investment intensity relative to ownership stake.
+        """)
+        fig6 = plot_ownership_and_investment_symbol(data)
+        st.plotly_chart(fig6, use_container_width=True)
+
+# Functions used in Page 4
+def plot_investor_count_and_ownership(df):
+    """
+    Plots investor count and ownership percentage.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing symbol ownership data.
+
+    Returns:
+        plotly.graph_objects.Figure: Plotly figure object.
+    """
+    fig = go.Figure()
+
+    # Investors Holding Line
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["investorsHolding"], 
+        mode='lines+markers', 
+        name="Investors Holding",
+        yaxis="y1"
+    ))
+
+    # Ownership Percentage Line
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["ownershipPercent"], 
+        mode='lines+markers', 
+        name="Ownership (%)",
+        yaxis="y2"
+    ))
+
+    fig.update_layout(
+        title="Investor Count and Ownership Percentage",
+        xaxis_title="Date",
+        yaxis=dict(title="Investors Holding"),
+        yaxis2=dict(title="Ownership (%)", overlaying="y", side="right", tickformat=".2f"),
+        legend=dict(title="Metrics"),
+        height=500
+    )
+    return fig
+
+def plot_portfolio_value_and_change_symbol(df):
+    """
+    Plots portfolio value and ownership percentage change.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing symbol ownership data.
+
+    Returns:
+        plotly.graph_objects.Figure: Plotly figure object.
+    """
+    fig = go.Figure()
+
+    # Total Invested Line
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["totalInvested"], 
+        mode='lines+markers', 
+        name="Total Invested",
+        yaxis="y1"
+    ))
+
+    # Ownership Percentage Change Line
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["ownershipPercentChange"], 
+        mode='lines+markers', 
+        name="Ownership Percent Change",
+        yaxis="y2"
+    ))
+
+    fig.update_layout(
+        title="Portfolio Value and Ownership Percentage Change",
+        xaxis_title="Date",
+        yaxis=dict(title="Total Invested ($)", tickformat="$,.0f"),
+        yaxis2=dict(title="Ownership Percent Change (%)", overlaying="y", side="right", tickformat=".2f"),
+        legend=dict(title="Metrics"),
+        height=500
+    )
+    return fig
+
+def plot_positions_activity_symbol(df):
+    """
+    Plots positions activity.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing symbol ownership data.
+
+    Returns:
+        plotly.graph_objects.Figure: Plotly figure object.
+    """
+    fig = go.Figure()
+
+    # New and Closed Positions Lines
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["newPositions"], 
+        mode='lines+markers', 
+        name="New Positions",
+        yaxis="y1"
+    ))
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["closedPositions"], 
+        mode='lines+markers', 
+        name="Closed Positions",
+        yaxis="y1"
+    ))
+
+    # Increased and Reduced Positions Lines
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["increasedPositions"], 
+        mode='lines+markers', 
+        name="Increased Positions",
+        yaxis="y2"
+    ))
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["reducedPositions"], 
+        mode='lines+markers', 
+        name="Reduced Positions",
+        yaxis="y2"
+    ))
+
+    fig.update_layout(
+        title="Positions Activity",
+        xaxis_title="Date",
+        yaxis=dict(title="New/Closed Positions"),
+        yaxis2=dict(title="Increased/Reduced Positions", overlaying="y", side="right"),
+        legend=dict(title="Metrics"),
+        height=500
+    )
+    return fig
+
+def plot_derivative_activity_symbol(df):
+    """
+    Plots derivative activity.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing symbol ownership data.
+
+    Returns:
+        plotly.graph_objects.Figure: Plotly figure object.
+    """
+    fig = go.Figure()
+
+    # Total Calls and Puts Lines
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["totalCalls"], 
+        mode='lines+markers', 
+        name="Total Calls",
+        yaxis="y1"
+    ))
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["totalPuts"], 
+        mode='lines+markers', 
+        name="Total Puts",
+        yaxis="y1"
+    ))
+
+    # Put/Call Ratio Line
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["putCallRatio"], 
+        mode='lines+markers', 
+        name="Put/Call Ratio",
+        yaxis="y2"
+    ))
+
+    fig.update_layout(
+        title="Derivative Activity",
+        xaxis_title="Date",
+        yaxis=dict(title="Total Calls/Puts"),
+        yaxis2=dict(title="Put/Call Ratio", overlaying="y", side="right", tickformat=".2f"),
+        legend=dict(title="Metrics"),
+        height=500
+    )
+    return fig
+
+def plot_changes_in_metrics_symbol(df):
+    """
+    Plots changes in metrics.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing symbol ownership data.
+
+    Returns:
+        plotly.graph_objects.Figure: Plotly figure object.
+    """
+    fig = go.Figure()
+
+    # Change in Number of 13F Shares
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["numberOf13FsharesChange"], 
+        mode='lines+markers', 
+        name="Change in 13F Shares",
+        yaxis="y1"
+    ))
+
+    # Change in Total Investment
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["totalInvestedChange"], 
+        mode='lines+markers', 
+        name="Change in Total Investment",
+        yaxis="y2"
+    ))
+
+    fig.update_layout(
+        title="Changes in Metrics",
+        xaxis_title="Date",
+        yaxis=dict(title="Change in 13F Shares"),
+        yaxis2=dict(title="Change in Total Investment ($)", overlaying="y", side="right", tickformat="$,.0f"),
+        legend=dict(title="Metrics"),
+        height=500
+    )
+    return fig
+
+def plot_ownership_and_investment_symbol(df):
+    """
+    Plots ownership percent and total invested.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing symbol ownership data.
+
+    Returns:
+        plotly.graph_objects.Figure: Plotly figure object.
+    """
+    fig = go.Figure()
+
+    # Ownership Percent
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["ownershipPercent"], 
+        mode='lines+markers', 
+        name="Ownership Percent",
+        yaxis="y1"
+    ))
+
+    # Total Invested
+    fig.add_trace(go.Scatter(
+        x=df["date"], 
+        y=df["totalInvested"], 
+        mode='lines+markers', 
+        name="Total Invested",
+        yaxis="y2"
+    ))
+
+    fig.update_layout(
+        title="Ownership Percent and Total Invested",
+        xaxis_title="Date",
+        yaxis=dict(title="Ownership Percent (%)"),
+        yaxis2=dict(title="Total Invested ($)", overlaying="y", side="right", tickformat="$,.0f"),
+        legend=dict(title="Metrics"),
+        height=500
+    )
+    return fig
+
+# Function for Main Navigation
+def main():
+    with st.sidebar.expander("Navigation", expanded=True):
+        page = st.radio("Go to", ["CIK List", "Portfolio Allocation", "Investor Performance", "Symbol Ownership"])
+    
+    if page == "CIK List":
+        page1()
+    elif page == "Portfolio Allocation":
+        page2()
+    elif page == "Investor Performance":
+        page3()
+    elif page == "Symbol Ownership":
+        page4()
+
+if __name__ == "__main__":
+    main()
+
+
+hide_streamlit_style = """
+<style>
+#MainMenu {visibility: hidden;}
+footer {visibility: hidden;}
+</style>
+"""
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)