Update app.py

app.py

@@ -26,9 +26,13 @@ default_tickers = ['BTC-USD', 'ETH-USD', 'BNB-USD', 'JPM', 'BAC', 'WFC', 'C']
 
 # Function to load adjusted close price data for a given ticker
 def load_ticker_ts_df(ticker, start, end):
-    data = yf.download(ticker, start=start, end=end)
-    return data['Close']
-    
+    data = yf.download(ticker, start=start, end=end, auto_adjust=False)  # Unadjusted prices
+    if isinstance(data.columns, pd.MultiIndex):  # Flatten multi-index
+        data.columns = data.columns.get_level_values(0)
+    if data.empty:
+        raise ValueError(f"No data found for {ticker}")
+    return data['Adj Close']
+
 # Function to calculate cross-correlation at different lags
 def cross_correlation(series1, series2, lag):
     if lag > 0:
@@ -37,34 +41,28 @@ def cross_correlation(series1, series2, lag):
         return np.corrcoef(series1[-lag:], series2[:lag])[0, 1]
     else:
         return np.corrcoef(series1, series2)[0, 1]
-        
+
 # Function to perform Granger causality test with shifted time series
 def granger_test_with_shift(data, target, predictor, shift):
-    shifted_data = data.copy()  # Make a copy of the data
-    # Shifting the predictor series by the specified lag
+    shifted_data = data.copy()
     shifted_data[predictor] = data[predictor].shift(shift)
-    # Dropping any NaN values created by the shift
     shifted_data.dropna(inplace=True)
-    # Performing Granger causality test
     granger_test_result = grangercausalitytests(shifted_data[[target, predictor]], maxlag=1, verbose=False)
-    # Extracting the p-value
     p_value = granger_test_result[1][0]['ssr_ftest'][1]
     return p_value
-    
+
 # Function to calculate cumulative profit
 def calculate_cumulative_profit(aligned_data, z_scores, buy_threshold, sell_threshold):
-    positions = []  # List to store open positions
-    profit = 0  # Initialize profit
-    cumulative_profits = []  # List to store cumulative profits over time
-    position_open = False  # Flag to indicate if a position is open
+    positions = []
+    profit = 0
+    cumulative_profits = []
+    position_open = False
 
-    # Iterate over the z-scores
     for i in range(len(z_scores)):
-        date = z_scores.index[i]  # Get the current date
-        z = z_scores.iloc[i]  # Get the current z-score
+        date = z_scores.index[i]
+        z = z_scores.iloc[i]
 
         if z > buy_threshold and not position_open:
-            # Open a short position on ticker2 and a long position on ticker1
             entry_date = date
             entry_price1 = aligned_data.loc[date, ticker1]
             entry_price2 = aligned_data.loc[date, ticker2]
@@ -72,7 +70,6 @@ def calculate_cumulative_profit(aligned_data, z_scores, buy_threshold, sell_thre
             positions.append((entry_date, 'sell', ticker2, entry_price2, 'buy', ticker1, entry_price1))
 
         elif z < sell_threshold and not position_open:
-            # Open a long position on ticker2 and a short position on ticker1
             entry_date = date
             entry_price1 = aligned_data.loc[date, ticker1]
             entry_price2 = aligned_data.loc[date, ticker2]
@@ -80,24 +77,21 @@ def calculate_cumulative_profit(aligned_data, z_scores, buy_threshold, sell_thre
             positions.append((entry_date, 'buy', ticker2, entry_price2, 'sell', ticker1, entry_price1))
 
         elif position_open and abs(z) < 0.5:
-            # Close the position when z-score crosses zero (mean reversion)
             exit_date = date
             exit_price1 = aligned_data.loc[date, ticker1]
             exit_price2 = aligned_data.loc[date, ticker2]
             position_open = False
-            entry = positions.pop()  # Get the last opened position
+            entry = positions.pop()
             entry_date, action1, tickerA, entry_priceA, action2, tickerB, entry_priceB = entry
 
             if action1 == 'sell':
-                # Calculate profit for short ticker2 and long ticker1
                 profit += (entry_priceA - exit_price2) + (exit_price1 - entry_priceB)
             else:
-                # Calculate profit for long ticker2 and short ticker1
                 profit += (exit_price2 - entry_priceA) + (entry_priceB - exit_price1)
 
-            cumulative_profits.append(profit)  # Append the current profit to the cumulative profits
+            cumulative_profits.append(profit)
 
-    return cumulative_profits, positions  # Return the cumulative profits and positions
+    return cumulative_profits, positions
 
 # Function to sanitize the data
 def sanitize_data(data_map):
@@ -128,7 +122,7 @@ def find_cointegrated_pairs(tickers_ts_map, p_value_threshold):
         result = coint(adj_close_data[:, i], adj_close_data[:, j])
         pvalue_matrix[i, j] = result[1]
         pvalue_matrix[j, i] = result[1]
-    np.fill_diagonal(pvalue_matrix, 0)  # Set diagonal to 0
+    np.fill_diagonal(pvalue_matrix, 0)
     pairs = [(tickers[i], tickers[j], pvalue_matrix[i, j]) for i in range(n) for j in range(i+1, n) if pvalue_matrix[i, j] < p_value_threshold]
     return pvalue_matrix, pairs
 
@@ -155,9 +149,9 @@ def find_cointegrated_pairs_rolling(tickers_ts_map, p_value_threshold, window_si
                 continue
             test_stat, crit_values = johansen_test(window_data)
             if test_stat[0] > crit_values[1, 1]:  # Using 95% critical value
-                pvalues.append(0.01)  # Assign a small p-value if cointegrated
+                pvalues.append(0.01)
             else:
-                pvalues.append(1)  # Assign a large p-value if not cointegrated
+                pvalues.append(1)
 
         pvalues = np.array(pvalues)
         consistent_cointegration = np.mean(pvalues < p_value_threshold)
@@ -193,270 +187,278 @@ if page == 'Pairs Trading Analysis':
         3. Click 'Run Analysis' to start the analysis.
         """)
 
-    # Expander for stock/crypto ticker and date selection
     with st.sidebar.expander("Stock/Crypto Ticker and Date Selection", expanded=True):
         ticker1 = st.text_input('Enter First Stock/Crypto Ticker', 'ASML.AS', help="Enter the ticker symbol for the first stock or cryptocurrency.")
         ticker2 = st.text_input('Enter Second Stock/Crypto Ticker', 'ASML', help="Enter the ticker symbol for the second stock or cryptocurrency.")
         start_date = st.date_input('Start Date', pd.to_datetime('2022-01-01'), help="Select the start date for the data range.")
         end_date = st.date_input('End Date', pd.to_datetime(END_DATE), help="Select the end date for the data range.")
 
-    # Expander for parameters specific to each method
     with st.sidebar.expander("Method Parameters", expanded=True):
         volatility_window = st.number_input('Volatility Window (days)', min_value=1, max_value=365, value=30, help="Set the number of days for the rolling volatility window.")
         buy_threshold = st.number_input('Buy Z-Score Threshold', value=2.0, help="Set the z-score threshold to generate buy signals.")
         sell_threshold = st.number_input('Sell Z-Score Threshold', value=-2.0, help="Set the z-score threshold to generate sell signals.")
 
     if st.sidebar.button('Run Analysis'):
-        # Data collection
-        data1 = yf.download(ticker1, start=start_date, end=end_date)['Close']
-        data2 = yf.download(ticker2, start=start_date, end=end_date)['Close']
-        aligned_data = pd.concat([data1, data2], axis=1, join='inner')
-        aligned_data.columns = [ticker1, ticker2]
-
-        # Normalize the price series
-        normalized_data = (aligned_data - aligned_data.mean()) / aligned_data.std()
-
-        # Plot normalized data
-        fig1 = go.Figure()
-        fig1.add_trace(go.Scatter(x=normalized_data.index, y=normalized_data[ticker1], mode='lines', name=f'Normalized {ticker1}'))
-        fig1.add_trace(go.Scatter(x=normalized_data.index, y=normalized_data[ticker2], mode='lines', name=f'Normalized {ticker2}'))
-        fig1.update_layout(title=f'Normalized Price Series for {ticker1} and {ticker2}', xaxis_title='Date', yaxis_title='Normalized Price')
-        st.plotly_chart(fig1)
-
-        # Calculate daily returns
-        returns = aligned_data.pct_change().dropna()
-
-        # Calculate rolling volatilities (annualized)
-        volatility1 = returns[ticker1].rolling(volatility_window).std() * np.sqrt(252)
-        volatility2 = returns[ticker2].rolling(volatility_window).std() * np.sqrt(252)
-
-        # Plot rolling volatilities
-        fig2 = go.Figure()
-        fig2.add_trace(go.Scatter(x=volatility1.index, y=volatility1, mode='lines', name=f"{ticker1} Volatility"))
-        fig2.add_trace(go.Scatter(x=volatility2.index, y=volatility2, mode='lines', name=f"{ticker2} Volatility"))
-        fig2.update_layout(title=f"{volatility_window}-Day Rolling Historical Volatility for {ticker1} and {ticker2}", xaxis_title='Date', yaxis_title='Volatility')
-        st.plotly_chart(fig2)
-
-        # Check for stationarity using ADF test
-        adf_result1 = adfuller(aligned_data[ticker1])
-        adf_result2 = adfuller(aligned_data[ticker2])
-
-        # Perform Johansen cointegration test
-        coint_test_stat, coint_critical_values = johansen_test(aligned_data)
-
-        # If cointegration exists, proceed with VECM
-        vecm = VECM(aligned_data, k_ar_diff=1, coint_rank=1)
-        vecm_fit = vecm.fit()
-
-        # Analyzing the residuals for stationarity
-        residuals = vecm_fit.resid
-        residuals_df = pd.DataFrame(residuals, index=aligned_data.index[-len(residuals):], columns=[f'Residual_{ticker1}', f'Residual_{ticker2}'])
-        adf_residuals_1 = adfuller(residuals[:, 0])
-        adf_residuals_2 = adfuller(residuals[:, 1])
-
-        # Plot residuals from VECM
-        fig3 = go.Figure()
-        fig3.add_trace(go.Scatter(x=residuals_df.index, y=residuals_df[f'Residual_{ticker1}'], mode='lines', name=f'Residual {ticker1}'))
-        fig3.add_trace(go.Scatter(x=residuals_df.index, y=residuals_df[f'Residual_{ticker2}'], mode='lines', name=f'Residual {ticker2}'))
-        fig3.add_hline(y=0, line=dict(color='red', dash='dash'), name='Zero Line')
-        fig3.update_layout(title='Residuals from VECM', xaxis_title='Date', yaxis_title='Residuals')
-        st.plotly_chart(fig3)
-
-        # Display ADF test results for the tickers
-        st.write(f"ADF Statistic for {ticker1}: {adf_result1[0]}, p-value: {adf_result1[1]}")
-        st.write(f"ADF Statistic for {ticker2}: {adf_result2[0]}, p-value: {adf_result2[1]}")
-
-        # Expander for "How it Works" inside the main body
-        with st.expander("How it Works", expanded=False):
-            st.markdown("""
-            **ADF Test:**
-            - The Augmented Dickey-Fuller (ADF) test checks whether a time series has a unit root, i.e., whether it is non-stationary.
-            - If the p-value is less than 0.05, we reject the null hypothesis that the series has a unit root, indicating that the series is stationary.
-            **Johansen Cointegration Test:**
-            - The Johansen test is used to determine the number of cointegrating relationships among multiple time series.
-            - If the test statistic is greater than the critical value, we reject the null hypothesis that there is no cointegration.
-            **VECM (Vector Error Correction Model):**
-            - A VECM is a special form of a VAR (Vector Autoregression) model used for cointegrated series. It corrects for disequilibrium in the short run while keeping the long-term relationship intact.
-            **Z-Score Trading Strategy:**
-            - Z-scores measure how many standard deviations an element is from the mean. In pairs trading, z-scores are used to identify overbought or oversold conditions, triggering buy or sell signals.
+        try:
+            # Data collection
+            data1 = yf.download(ticker1, start=start_date, end=end_date, auto_adjust=False)
+            if isinstance(data1.columns, pd.MultiIndex):
+                data1.columns = data1.columns.get_level_values(0)
+            data2 = yf.download(ticker2, start=start_date, end=end_date, auto_adjust=False)
+            if isinstance(data2.columns, pd.MultiIndex):
+                data2.columns = data2.columns.get_level_values(0)
+            
+            if data1.empty or data2.empty:
+                raise ValueError(f"No data found for {ticker1} or {ticker2}")
+            
+            aligned_data = pd.concat([data1['Close'], data2['Close']], axis=1, join='inner')
+            aligned_data.columns = [ticker1, ticker2]
+
+            # Normalize the price series
+            normalized_data = (aligned_data - aligned_data.mean()) / aligned_data.std()
+
+            # Plot normalized data
+            fig1 = go.Figure()
+            fig1.add_trace(go.Scatter(x=normalized_data.index, y=normalized_data[ticker1], mode='lines', name=f'Normalized {ticker1}'))
+            fig1.add_trace(go.Scatter(x=normalized_data.index, y=normalized_data[ticker2], mode='lines', name=f'Normalized {ticker2}'))
+            fig1.update_layout(title=f'Normalized Price Series for {ticker1} and {ticker2}', xaxis_title='Date', yaxis_title='Normalized Price')
+            st.plotly_chart(fig1)
+
+            # Calculate daily returns
+            returns = aligned_data.pct_change().dropna()
+
+            # Calculate rolling volatilities (annualized)
+            volatility1 = returns[ticker1].rolling(volatility_window).std() * np.sqrt(252)
+            volatility2 = returns[ticker2].rolling(volatility_window).std() * np.sqrt(252)
+
+            # Plot rolling volatilities
+            fig2 = go.Figure()
+            fig2.add_trace(go.Scatter(x=volatility1.index, y=volatility1, mode='lines', name=f"{ticker1} Volatility"))
+            fig2.add_trace(go.Scatter(x=volatility2.index, y=volatility2, mode='lines', name=f"{ticker2} Volatility"))
+            fig2.update_layout(title=f"{volatility_window}-Day Rolling Historical Volatility for {ticker1} and {ticker2}", xaxis_title='Date', yaxis_title='Volatility')
+            st.plotly_chart(fig2)
+
+            # Check for stationarity using ADF test
+            adf_result1 = adfuller(aligned_data[ticker1])
+            adf_result2 = adfuller(aligned_data[ticker2])
+
+            # Perform Johansen cointegration test
+            coint_test_stat, coint_critical_values = johansen_test(aligned_data)
+
+            # If cointegration exists, proceed with VECM
+            vecm = VECM(aligned_data, k_ar_diff=1, coint_rank=1)
+            vecm_fit = vecm.fit()
+
+            # Analyzing the residuals for stationarity
+            residuals = vecm_fit.resid
+            residuals_df = pd.DataFrame(residuals, index=aligned_data.index[-len(residuals):], columns=[f'Residual_{ticker1}', f'Residual_{ticker2}'])
+            adf_residuals_1 = adfuller(residuals[:, 0])
+            adf_residuals_2 = adfuller(residuals[:, 1])
+
+            # Plot residuals from VECM
+            fig3 = go.Figure()
+            fig3.add_trace(go.Scatter(x=residuals_df.index, y=residuals_df[f'Residual_{ticker1}'], mode='lines', name=f'Residual {ticker1}'))
+            fig3.add_trace(go.Scatter(x=residuals_df.index, y=residuals_df[f'Residual_{ticker2}'], mode='lines', name=f'Residual {ticker2}'))
+            fig3.add_hline(y=0, line=dict(color='red', dash='dash'), name='Zero Line')
+            fig3.update_layout(title='Residuals from VECM', xaxis_title='Date', yaxis_title='Residuals')
+            st.plotly_chart(fig3)
+
+            # Display ADF test results for the tickers
+            st.write(f"ADF Statistic for {ticker1}: {adf_result1[0]}, p-value: {adf_result1[1]}")
+            st.write(f"ADF Statistic for {ticker2}: {adf_result2[0]}, p-value: {adf_result2[1]}")
+
+            with st.expander("How it Works", expanded=False):
+                st.markdown("""
+                **ADF Test:**
+                - The Augmented Dickey-Fuller (ADF) test checks whether a time series has a unit root, i.e., whether it is non-stationary.
+                - If the p-value is less than 0.05, we reject the null hypothesis that the series has a unit root, indicating that the series is stationary.
+                **Johansen Cointegration Test:**
+                - The Johansen test is used to determine the number of cointegrating relationships among multiple time series.
+                - If the test statistic is greater than the critical value, we reject the null hypothesis that there is no cointegration.
+                **VECM (Vector Error Correction Model):**
+                - A VECM is a special form of a VAR (Vector Autoregression) model used for cointegrated series. It corrects for disequilibrium in the short run while keeping the long-term relationship intact.
+                **Z-Score Trading Strategy:**
+                - Z-scores measure how many standard deviations an element is from the mean. In pairs trading, z-scores are used to identify overbought or oversold conditions, triggering buy or sell signals.
+                """)
+
+            st.markdown("#### Interpretation of ADF Results")
+            st.latex(r'''
+            H_0: \text{The series has a unit root (non-stationary)} \\
+            H_1: \text{The series does not have a unit root (stationary)}
+            ''')
+            st.write("""
+            - The Augmented Dickey-Fuller (ADF) test checks the null hypothesis that a unit root is present in a time series sample.
             """)
+            if adf_result1[1] < 0.05:
+                st.write(f"{ticker1} is stationary, indicating the series does not have a unit root.")
+            else:
+                st.write(f"{ticker1} is not stationary, indicating the series has a unit root.")
 
-        st.markdown("#### Interpretation of ADF Results")
-        st.latex(r'''
-        H_0: \text{The series has a unit root (non-stationary)} \\
-        H_1: \text{The series does not have a unit root (stationary)}
-        ''')
-        st.write("""
-        - The Augmented Dickey-Fuller (ADF) test checks the null hypothesis that a unit root is present in a time series sample.
-        """)
-        if adf_result1[1] < 0.05:
-            st.write(f"{ticker1} is stationary, indicating the series does not have a unit root.")
-        else:
-            st.write(f"{ticker1} is not stationary, indicating the series has a unit root.")
-
-        if adf_result2[1] < 0.05:
-            st.write(f"{ticker2} is stationary, indicating the series does not have a unit root.")
-        else:
-            st.write(f"{ticker2} is not stationary, indicating the series has a unit root.")
-
-        # Display cointegration test results
-        st.write("Johansen Cointegration Test Results:")
-        johansen_results = pd.DataFrame({
-            'Test Statistic': coint_test_stat,
-            '90% Critical Value': coint_critical_values[:, 0],
-            '95% Critical Value': coint_critical_values[:, 1],
-            '99% Critical Value': coint_critical_values[:, 2]
-        }, index=[f'Cointegration Test {i+1}' for i in range(len(coint_test_stat))])
-        st.write(johansen_results)
-
-        st.markdown("#### Interpretation of Johansen Cointegration Test Results")
-        st.latex(r'''
-        H_0: \text{No cointegration relationship exists} \\
-        H_1: \text{Cointegration relationship exists}
-        ''')
-        st.write("""
-        - The Johansen cointegration test is used to determine the cointegration rank between multiple time series.
-        """)
-        if coint_test_stat[0] > coint_critical_values[0, 1]:
-            st.write(f"The two assets {ticker1} and {ticker2} are cointegrated at the 95% confidence level.")
-        else:
-            st.write(f"The two assets {ticker1} and {ticker2} are not cointegrated at the 95% confidence level.")
+            if adf_result2[1] < 0.05:
+                st.write(f"{ticker2} is stationary, indicating the series does not have a unit root.")
+            else:
+                st.write(f"{ticker2} is not stationary, indicating the series has a unit root.")
+
+            # Display cointegration test results
+            st.write("Johansen Cointegration Test Results:")
+            johansen_results = pd.DataFrame({
+                'Test Statistic': coint_test_stat,
+                '90% Critical Value': coint_critical_values[:, 0],
+                '95% Critical Value': coint_critical_values[:, 1],
+                '99% Critical Value': coint_critical_values[:, 2]
+            }, index=[f'Cointegration Test {i+1}' for i in range(len(coint_test_stat))])
+            st.write(johansen_results)
+
+            st.markdown("#### Interpretation of Johansen Cointegration Test Results")
+            st.latex(r'''
+            H_0: \text{No cointegration relationship exists} \\
+            H_1: \text{Cointegration relationship exists}
+            ''')
+            st.write("""
+            - The Johansen cointegration test is used to determine the cointegration rank between multiple time series.
+            """)
+            if coint_test_stat[0] > coint_critical_values[0, 1]:
+                st.write(f"The two assets {ticker1} and {ticker2} are cointegrated at the 95% confidence level.")
+            else:
+                st.write(f"The two assets {ticker1} and {ticker2} are not cointegrated at the 95% confidence level.")
 
-        st.markdown("#### Interpretation of VECM Residuals")
-        st.write(f"ADF Statistic for VECM residuals of {ticker1}: {adf_residuals_1[0]}, p-value: {adf_residuals_1[1]}")
-        st.write(f"ADF Statistic for VECM residuals of {ticker2}: {adf_residuals_2[0]}, p-value: {adf_residuals_2[1]}")
-        st.write("""
-        - The residuals from the Vector Error Correction Model (VECM) should be stationary to confirm cointegration.
-        """)
-        if adf_residuals_1[1] < 0.1:
-            st.write(f"The residuals of the VECM model for {ticker1} are stationary, confirming cointegration.")
-        else:
-            st.write(f"The residuals of the VECM model for {ticker1} are not stationary, suggesting no cointegration.")
+            st.markdown("#### Interpretation of VECM Residuals")
+            st.write(f"ADF Statistic for VECM residuals of {ticker1}: {adf_residuals_1[0]}, p-value: {adf_residuals_1[1]}")
+            st.write(f"ADF Statistic for VECM residuals of {ticker2}: {adf_residuals_2[0]}, p-value: {adf_residuals_2[1]}")
+            st.write("""
+            - The residuals from the Vector Error Correction Model (VECM) should be stationary to confirm cointegration.
+            """)
+            if adf_residuals_1[1] < 0.1:
+                st.write(f"The residuals of the VECM model for {ticker1} are stationary, confirming cointegration.")
+            else:
+                st.write(f"The residuals of the VECM model for {ticker1} are not stationary, suggesting no cointegration.")
 
-        if adf_residuals_2[1] < 0.1:
-            st.write(f"The residuals of the VECM model for {ticker2} are stationary, confirming cointegration.")
-        else:
-            st.write(f"The residuals of the VECM model for {ticker2} are not stationary, suggesting no cointegration.")
-
-        # Calculate cross-correlation for a range of lags
-        lag_range = range(-30, 31)
-        cross_correlations = [cross_correlation(returns[ticker1], returns[ticker2], lag) for lag in lag_range]
-
-        # Plot cross-correlation for different lags
-        fig4 = go.Figure()
-        fig4.add_trace(go.Scatter(x=list(lag_range), y=cross_correlations, mode='lines+markers'))
-        fig4.add_hline(y=0, line=dict(color='gray', dash='dash'))
-        fig4.add_vline(x=0, line=dict(color='red', dash='dash'))
-        fig4.update_layout(title=f"Cross-Correlation between {ticker1} and {ticker2}", xaxis_title='Lag (days)', yaxis_title='Cross-Correlation')
-        st.plotly_chart(fig4)
-
-        st.markdown("#### Interpretation of Cross-Correlation Results")
-        max_corr = max(cross_correlations)
-        max_lag = lag_range[cross_correlations.index(max_corr)]
-        second_max_corr = max(corr for i, corr in enumerate(cross_correlations) if corr != max_corr)
-        second_max_lag = lag_range[cross_correlations.index(second_max_corr)]
-
-        st.write(f"Highest correlation: {max_corr:.2f} at lag {max_lag}")
-        st.write(f"Second highest correlation: {second_max_corr:.2f} at lag {second_max_lag}")
-
-        interpretation = f"Highest correlation at lag {max_lag}: The high correlation at lag {max_lag} indicates that {ticker1} and {ticker2} move together without any significant lead or lag. In other words, any movements in {ticker1} are almost instantaneously reflected in {ticker2} and vice versa. This is typical for cross-listed assets, where information and price changes are quickly reflected in both markets.\n"
-
-        if second_max_lag < 0:
-            leading_ticker = ticker2
-            lagging_ticker = ticker1
-            lead_days = abs(second_max_lag)
-            direction = f"Second highest correlation at lag {second_max_lag}: {leading_ticker} leads {lagging_ticker} by {lead_days} days. This means that movements in {leading_ticker} tend to precede similar movements in {lagging_ticker} by {lead_days} day(s)."
-        elif second_max_lag > 0:
-            leading_ticker = ticker1
-            lagging_ticker = ticker2
-            lead_days = second_max_lag
-            direction = f"Second highest correlation at lag {second_max_lag}: {leading_ticker} leads {lagging_ticker} by {lead_days} days. This means that movements in {leading_ticker} tend to precede similar movements in {lagging_ticker} by {lead_days} day(s)."
-        else:
-            direction = "No significant lead/lag relationship; they move simultaneously."
-        interpretation += direction
-        st.write(interpretation)
-
-        # Granger causality test with shifts
-        shift_range = range(-5, 6)
-        granger_p_values_shift_1_to_2 = {shift: granger_test_with_shift(aligned_data, ticker1, ticker2, shift) for shift in shift_range}
-        granger_p_values_shift_2_to_1 = {shift: granger_test_with_shift(aligned_data, ticker2, ticker1, shift) for shift in shift_range}
-
-        # Create DataFrames for plotting Granger causality test results
-        granger_p_values_df_shift_1_to_2 = pd.DataFrame(granger_p_values_shift_1_to_2, index=[f"{ticker1} causes {ticker2}"]).T
-        granger_p_values_df_shift_2_to_1 = pd.DataFrame(granger_p_values_shift_2_to_1, index=[f"{ticker2} causes {ticker1}"]).T
-
-        # Plot Granger causality test p-values with shifts
-        fig5 = go.Figure()
-        fig5.add_trace(go.Scatter(x=granger_p_values_df_shift_1_to_2.index, y=granger_p_values_df_shift_1_to_2[f"{ticker1} causes {ticker2}"], mode='lines+markers', name=f"{ticker1} causes {ticker2}"))
-        fig5.add_trace(go.Scatter(x=granger_p_values_df_shift_2_to_1.index, y=granger_p_values_df_shift_2_to_1[f"{ticker2} causes {ticker1}"], mode='lines+markers', name=f"{ticker2} causes {ticker1}"))
-        fig5.add_hline(y=0.05, line=dict(color='gray', dash='dash'))
-        fig5.add_vline(x=0, line=dict(color='red', dash='dash'))
-        fig5.update_layout(title=f"Granger Causality Test p-values with Shifts between {ticker1} and {ticker2}", xaxis_title='Shift (days)', yaxis_title='p-value')
-        st.plotly_chart(fig5)
-
-        st.markdown("#### Interpretation of Granger Causality Test Results")
-        best_lag_1_to_2 = min(granger_p_values_shift_1_to_2, key=granger_p_values_shift_1_to_2.get)
-        best_lag_2_to_1 = min(granger_p_values_shift_2_to_1, key=granger_p_values_shift_2_to_1.get)
-
-        interpretation = ""
-
-        if granger_p_values_shift_1_to_2[best_lag_1_to_2] < 0.05 and granger_p_values_shift_1_to_2[best_lag_1_to_2] < granger_p_values_shift_2_to_1[best_lag_2_to_1]:
-            causality_direction = f"{ticker1} causes {ticker2}"
-            best_lag = best_lag_1_to_2
-            interpretation += f"Granger causality test with shifts suggests that {ticker1} causes {ticker2} with a lag of {abs(best_lag)} days.\n"
-            interpretation += f"This means that movements in {ticker1} tend to lead movements in {ticker2} by {abs(best_lag)} days. In practical terms, if {ticker1} experiences a price change, we can expect a similar change in {ticker2} approximately {abs(best_lag)} days later."
-        else:
-            causality_direction = f"{ticker2} causes {ticker1}"
-            best_lag = best_lag_2_to_1
-            interpretation += f"Granger causality test with shifts suggests that {ticker2} causes {ticker1} with a lag of {abs(best_lag)} days.\n"
-            interpretation += f"This means that movements in {ticker2} tend to lead movements in {ticker1} by {abs(best_lag)} days. In practical terms, if {ticker2} experiences a price change, we can expect a similar change in {ticker1} approximately {abs(best_lag)} days later."
-
-        st.write(interpretation)
-
-        # Adjust data based on the identified best lag
-        adjusted_data = aligned_data.copy()
-        adjusted_data[ticker1] = adjusted_data[ticker1].shift(best_lag).dropna()
-        adjusted_data = adjusted_data.dropna()
-
-        # Calculate the residuals
-        model = OLS(adjusted_data[ticker2], adjusted_data[ticker1])
-        results = model.fit()
-        residuals = adjusted_data[ticker2] - results.params[ticker1] * adjusted_data[ticker1]
-
-        # Calculate Z-Scores
-        residuals_mean = residuals.mean()
-        residuals_std = residuals.std()
-        z_scores = (residuals - residuals_mean) / residuals_std
-
-        # Generate buy and sell signals
-        buy_signals = z_scores[z_scores > buy_threshold]
-        sell_signals = z_scores[z_scores < sell_threshold]
-
-        # Plot the residuals with buy and sell signals
-        fig6 = go.Figure()
-        fig6.add_trace(go.Scatter(x=z_scores.index, y=z_scores, mode='lines', name='Z-Score of Residuals'))
-        fig6.add_trace(go.Scatter(x=buy_signals.index, y=buy_signals, mode='markers', marker=dict(color='green', symbol='triangle-up', size=10), name=f'Buy {ticker1}, Sell {ticker2} Signal'))
-        fig6.add_trace(go.Scatter(x=sell_signals.index, y=sell_signals, mode='markers', marker=dict(color='red', symbol='triangle-down', size=10), name=f'Sell {ticker1}, Buy {ticker2} Signal'))
-        fig6.add_hline(y=buy_threshold, line=dict(color='gray', dash='dash'))
-        fig6.add_hline(y=sell_threshold, line=dict(color='gray', dash='dash'))
-        fig6.update_layout(title=f"Residuals (Adjusted for Lag) with Buy and Sell Signals based on Z-Scores", xaxis_title='Date', yaxis_title='Z-Score')
-        st.plotly_chart(fig6)
-
-        # Calculate cumulative profits and positions
-        cumulative_profits, positions = calculate_cumulative_profit(aligned_data, z_scores, buy_threshold, sell_threshold)
-
-        # Plot the cumulative profit
-        fig7 = go.Figure()
-        fig7.add_trace(go.Scatter(x=aligned_data.index[:len(cumulative_profits)], y=cumulative_profits, mode='lines', name='Cumulative Profit'))
-        fig7.update_layout(title=f"Cumulative Profit from Z-Score Trading Strategy", xaxis_title='Date', yaxis_title='Cumulative Profit')
-        st.plotly_chart(fig7)
-
-        st.markdown("#### Interpretation of Trading Signals and Cumulative Profit")
-        st.write(f"Cumulative Profit: {cumulative_profits[-1]:.2f}")
-        st.write("""
-        - The trading strategy uses z-scores to generate buy and sell signals.
-        - The cumulative profit shows the total profit from the trading strategy over the analyzed period.
-        """)
+            if adf_residuals_2[1] < 0.1:
+                st.write(f"The residuals of the VECM model for {ticker2} are stationary, confirming cointegration.")
+            else:
+                st.write(f"The residuals of the VECM model for {ticker2} are not stationary, suggesting no cointegration.")
+
+            # Calculate cross-correlation for a range of lags
+            lag_range = range(-30, 31)
+            cross_correlations = [cross_correlation(returns[ticker1], returns[ticker2], lag) for lag in lag_range]
+
+            # Plot cross-correlation for different lags
+            fig4 = go.Figure()
+            fig4.add_trace(go.Scatter(x=list(lag_range), y=cross_correlations, mode='lines+markers'))
+            fig4.add_hline(y=0, line=dict(color='gray', dash='dash'))
+            fig4.add_vline(x=0, line=dict(color='red', dash='dash'))
+            fig4.update_layout(title=f"Cross-Correlation between {ticker1} and {ticker2}", xaxis_title='Lag (days)', yaxis_title='Cross-Correlation')
+            st.plotly_chart(fig4)
+
+            st.markdown("#### Interpretation of Cross-Correlation Results")
+            max_corr = max(cross_correlations)
+            max_lag = lag_range[cross_correlations.index(max_corr)]
+            second_max_corr = max(corr for i, corr in enumerate(cross_correlations) if corr != max_corr)
+            second_max_lag = lag_range[cross_correlations.index(second_max_corr)]
+
+            st.write(f"Highest correlation: {max_corr:.2f} at lag {max_lag}")
+            st.write(f"Second highest correlation: {second_max_corr:.2f} at lag {second_max_lag}")
+
+            interpretation = f"Highest correlation at lag {max_lag}: The high correlation at lag {max_lag} indicates that {ticker1} and {ticker2} move together without any significant lead or lag. In other words, any movements in {ticker1} are almost instantaneously reflected in {ticker2} and vice versa. This is typical for cross-listed assets, where information and price changes are quickly reflected in both markets.\n"
+
+            if second_max_lag < 0:
+                leading_ticker = ticker2
+                lagging_ticker = ticker1
+                lead_days = abs(second_max_lag)
+                direction = f"Second highest correlation at lag {second_max_lag}: {leading_ticker} leads {lagging_ticker} by {lead_days} days. This means that movements in {leading_ticker} tend to precede similar movements in {lagging_ticker} by {lead_days} day(s)."
+            elif second_max_lag > 0:
+                leading_ticker = ticker1
+                lagging_ticker = ticker2
+                lead_days = second_max_lag
+                direction = f"Second highest correlation at lag {second_max_lag}: {leading_ticker} leads {lagging_ticker} by {lead_days} days. This means that movements in {leading_ticker} tend to precede similar movements in {lagging_ticker} by {lead_days} day(s)."
+            else:
+                direction = "No significant lead/lag relationship; they move simultaneously."
+            interpretation += direction
+            st.write(interpretation)
+
+            # Granger causality test with shifts
+            shift_range = range(-5, 6)
+            granger_p_values_shift_1_to_2 = {shift: granger_test_with_shift(aligned_data, ticker1, ticker2, shift) for shift in shift_range}
+            granger_p_values_shift_2_to_1 = {shift: granger_test_with_shift(aligned_data, ticker2, ticker1, shift) for shift in shift_range}
+
+            # Create DataFrames for plotting Granger causality test results
+            granger_p_values_df_shift_1_to_2 = pd.DataFrame(granger_p_values_shift_1_to_2, index=[f"{ticker1} causes {ticker2}"]).T
+            granger_p_values_df_shift_2_to_1 = pd.DataFrame(granger_p_values_shift_2_to_1, index=[f"{ticker2} causes {ticker1}"]).T
+
+            # Plot Granger causality test p-values with shifts
+            fig5 = go.Figure()
+            fig5.add_trace(go.Scatter(x=granger_p_values_df_shift_1_to_2.index, y=granger_p_values_df_shift_1_to_2[f"{ticker1} causes {ticker2}"], mode='lines+markers', name=f"{ticker1} causes {ticker2}"))
+            fig5.add_trace(go.Scatter(x=granger_p_values_df_shift_2_to_1.index, y=granger_p_values_df_shift_2_to_1[f"{ticker2} causes {ticker1}"], mode='lines+markers', name=f"{ticker2} causes {ticker1}"))
+            fig5.add_hline(y=0.05, line=dict(color='gray', dash='dash'))
+            fig5.add_vline(x=0, line=dict(color='red', dash='dash'))
+            fig5.update_layout(title=f"Granger Causality Test p-values with Shifts between {ticker1} and {ticker2}", xaxis_title='Shift (days)', yaxis_title='p-value')
+            st.plotly_chart(fig5)
+
+            st.markdown("#### Interpretation of Granger Causality Test Results")
+            best_lag_1_to_2 = min(granger_p_values_shift_1_to_2, key=granger_p_values_shift_1_to_2.get)
+            best_lag_2_to_1 = min(granger_p_values_shift_2_to_1, key=granger_p_values_shift_2_to_1.get)
+
+            interpretation = ""
+
+            if granger_p_values_shift_1_to_2[best_lag_1_to_2] < 0.05 and granger_p_values_shift_1_to_2[best_lag_1_to_2] < granger_p_values_shift_2_to_1[best_lag_2_to_1]:
+                causality_direction = f"{ticker1} causes {ticker2}"
+                best_lag = best_lag_1_to_2
+                interpretation += f"Granger causality test with shifts suggests that {ticker1} causes {ticker2} with a lag of {abs(best_lag)} days.\n"
+                interpretation += f"This means that movements in {ticker1} tend to lead movements in {ticker2} by {abs(best_lag)} days. In practical terms, if {ticker1} experiences a price change, we can expect a similar change in {ticker2} approximately {abs(best_lag)} days later."
+            else:
+                causality_direction = f"{ticker2} causes {ticker1}"
+                best_lag = best_lag_2_to_1
+                interpretation += f"Granger causality test with shifts suggests that {ticker2} causes {ticker1} with a lag of {abs(best_lag)} days.\n"
+                interpretation += f"This means that movements in {ticker2} tend to lead movements in {ticker1} by {abs(best_lag)} days. In practical terms, if {ticker2} experiences a price change, we can expect a similar change in {ticker1} approximately {abs(best_lag)} days later."
+
+            st.write(interpretation)
+
+            # Adjust data based on the identified best lag
+            adjusted_data = aligned_data.copy()
+            adjusted_data[ticker1] = adjusted_data[ticker1].shift(best_lag).dropna()
+            adjusted_data = adjusted_data.dropna()
+
+            # Calculate the residuals
+            model = OLS(adjusted_data[ticker2], adjusted_data[ticker1])
+            results = model.fit()
+            residuals = adjusted_data[ticker2] - results.params[ticker1] * adjusted_data[ticker1]
+
+            # Calculate Z-Scores
+            residuals_mean = residuals.mean()
+            residuals_std = residuals.std()
+            z_scores = (residuals - residuals_mean) / residuals_std
+
+            # Generate buy and sell signals
+            buy_signals = z_scores[z_scores > buy_threshold]
+            sell_signals = z_scores[z_scores < sell_threshold]
+
+            # Plot the residuals with buy and sell signals
+            fig6 = go.Figure()
+            fig6.add_trace(go.Scatter(x=z_scores.index, y=z_scores, mode='lines', name='Z-Score of Residuals'))
+            fig6.add_trace(go.Scatter(x=buy_signals.index, y=buy_signals, mode='markers', marker=dict(color='green', symbol='triangle-up', size=10), name=f'Buy {ticker1}, Sell {ticker2} Signal'))
+            fig6.add_trace(go.Scatter(x=sell_signals.index, y=sell_signals, mode='markers', marker=dict(color='red', symbol='triangle-down', size=10), name=f'Sell {ticker1}, Buy {ticker2} Signal'))
+            fig6.add_hline(y=buy_threshold, line=dict(color='gray', dash='dash'))
+            fig6.add_hline(y=sell_threshold, line=dict(color='gray', dash='dash'))
+            fig6.update_layout(title=f"Residuals (Adjusted for Lag) with Buy and Sell Signals based on Z-Scores", xaxis_title='Date', yaxis_title='Z-Score')
+            st.plotly_chart(fig6)
+
+            # Calculate cumulative profits and positions
+            cumulative_profits, positions = calculate_cumulative_profit(aligned_data, z_scores, buy_threshold, sell_threshold)
+
+            # Plot the cumulative profit
+            fig7 = go.Figure()
+            fig7.add_trace(go.Scatter(x=aligned_data.index[:len(cumulative_profits)], y=cumulative_profits, mode='lines', name='Cumulative Profit'))
+            fig7.update_layout(title=f"Cumulative Profit from Z-Score Trading Strategy", xaxis_title='Date', yaxis_title='Cumulative Profit')
+            st.plotly_chart(fig7)
+
+            st.markdown("#### Interpretation of Trading Signals and Cumulative Profit")
+            st.write(f"Cumulative Profit: {cumulative_profits[-1]:.2f}")
+            st.write("""
+            - The trading strategy uses z-scores to generate buy and sell signals.
+            - The cumulative profit shows the total profit from the trading strategy over the analyzed period.
+            """)
+        except Exception as e:
+            st.error(f"Error: {str(e)}. Check ticker symbols or date range.")
 
 elif page == 'Pair Cointegration Identification':
     st.subheader("Cointegration Identification")
@@ -466,65 +468,54 @@ elif page == 'Pair Cointegration Identification':
     It works for both stocks and cryptocurrency pairs.
     """)
 
-    # Cointegration Method Selection
     method = st.sidebar.selectbox('Select Cointegration Method', ['Engle-Granger', 'Johansen Cointegration'])
 
-    # Expander for stock/crypto ticker and date selection
     with st.sidebar.expander("Stock/Crypto Ticker and Date Selection", expanded=True):
         tickers_input = st.text_input('Enter Stock or Crypto Tickers (comma-separated)', ', '.join(default_tickers), help="Enter the ticker symbols for stocks or cryptocurrencies you want to analyze.")
         start_date = st.date_input('Start Date', pd.to_datetime(START_DATE), help="Select the start date for the data range.")
         end_date = st.date_input('End Date', pd.to_datetime(END_DATE), help="Select the end date for the data range.")
 
-    # Expander for parameters specific to each method
-    #with st.sidebar.expander("Method Parameters", expanded=True):
-    #    st.write("Set parameters for the selected method.")
-
     if st.sidebar.button('Run Cointegration Analysis'):
-        tickers = [ticker.strip() for ticker in tickers_input.split(',')]
-        universe_tickers_ts_map = {ticker: load_ticker_ts_df(ticker, start_date, end_date) for ticker in tickers}
-        uts_sanitized = sanitize_data(universe_tickers_ts_map)
-
-        if method == 'Engle-Granger':
-            # Find cointegrated pairs using the Engle-Granger method
-            pvalues, pairs = find_cointegrated_pairs(uts_sanitized, P_VALUE_THRESHOLD)
-            # Mask values greater than P_VALUE_THRESHOLD
-            masked_pvalues = np.where(pvalues > P_VALUE_THRESHOLD, np.nan, pvalues)
-            # Plot heatmap of p-values
-            tickers_list = list(uts_sanitized.keys())
-            fig_heatmap = px.imshow(masked_pvalues, x=tickers_list, y=tickers_list,
-                                    color_continuous_scale='RdYlGn_r', title='Cointegration Heatmap (Engle-Granger)',
-                                    labels=dict(x='Tickers', y='Tickers', color='P-value'),
-                                    zmin=0, zmax=P_VALUE_THRESHOLD)
-        else:
-            # Find cointegrated pairs using the Johansen method with rolling windows
-            pvalues, pairs = find_cointegrated_pairs_rolling(uts_sanitized, P_VALUE_THRESHOLD, ROLLING_WINDOW_SIZE, CONSISTENT_COINTEGRATION_THRESHOLD)
-            # Mask values greater than P_VALUE_THRESHOLD
-            masked_pvalues = np.where(pvalues > P_VALUE_THRESHOLD, np.nan, pvalues)
-            # Plot heatmap of p-values
-            tickers_list = list(uts_sanitized.keys())
-            fig_heatmap = px.imshow(masked_pvalues, x=tickers_list, y=tickers_list,
-                                    color_continuous_scale='RdYlGn_r', title='Cointegration Heatmap (Johansen)',
-                                    labels=dict(x='Tickers', y='Tickers', color='P-value'),
-                                    zmin=0, zmax=P_VALUE_THRESHOLD)
-        
-        st.plotly_chart(fig_heatmap)
-        
-        # Sort pairs by p-value (ascending) and select the top 10
-        top_10_pairs = sorted(pairs, key=lambda x: x[2])[:10]
-        
-        # Extract data for the bar plot
-        pair_labels = [f"{pair[0]} & {pair[1]}" for pair in top_10_pairs]
-        pair_values = [pair[2] for pair in top_10_pairs]
-        
-        # Plot bar chart
-        fig_bar = go.Figure([go.Bar(x=pair_values, y=pair_labels, orientation='h')])
-        fig_bar.update_layout(title='Top 10 Most Cointegrated Pairs',
-                              xaxis_title='P-value',
-                              yaxis_title='Asset Pairs',
-                              yaxis=dict(autorange='reversed'))
-        st.plotly_chart(fig_bar)
-
-    # Expander for "How it Works" inside the main body
+        try:
+            tickers = [ticker.strip() for ticker in tickers_input.split(',')]
+            universe_tickers_ts_map = {ticker: load_ticker_ts_df(ticker, start_date, end_date) for ticker in tickers}
+            uts_sanitized = sanitize_data(universe_tickers_ts_map)
+
+            if not uts_sanitized:
+                raise ValueError("No valid data after sanitization. Check tickers or date range.")
+
+            if method == 'Engle-Granger':
+                pvalues, pairs = find_cointegrated_pairs(uts_sanitized, P_VALUE_THRESHOLD)
+                masked_pvalues = np.where(pvalues > P_VALUE_THRESHOLD, np.nan, pvalues)
+                tickers_list = list(uts_sanitized.keys())
+                fig_heatmap = px.imshow(masked_pvalues, x=tickers_list, y=tickers_list,
+                                        color_continuous_scale='RdYlGn_r', title='Cointegration Heatmap (Engle-Granger)',
+                                        labels=dict(x='Tickers', y='Tickers', color='P-value'),
+                                        zmin=0, zmax=P_VALUE_THRESHOLD)
+            else:
+                pvalues, pairs = find_cointegrated_pairs_rolling(uts_sanitized, P_VALUE_THRESHOLD, ROLLING_WINDOW_SIZE, CONSISTENT_COINTEGRATION_THRESHOLD)
+                masked_pvalues = np.where(pvalues > P_VALUE_THRESHOLD, np.nan, pvalues)
+                tickers_list = list(uts_sanitized.keys())
+                fig_heatmap = px.imshow(masked_pvalues, x=tickers_list, y=tickers_list,
+                                        color_continuous_scale='RdYlGn_r', title='Cointegration Heatmap (Johansen)',
+                                        labels=dict(x='Tickers', y='Tickers', color='P-value'),
+                                        zmin=0, zmax=P_VALUE_THRESHOLD)
+            
+            st.plotly_chart(fig_heatmap)
+            
+            top_10_pairs = sorted(pairs, key=lambda x: x[2])[:10]
+            pair_labels = [f"{pair[0]} & {pair[1]}" for pair in top_10_pairs]
+            pair_values = [pair[2] for pair in top_10_pairs]
+            
+            fig_bar = go.Figure([go.Bar(x=pair_values, y=pair_labels, orientation='h')])
+            fig_bar.update_layout(title='Top 10 Most Cointegrated Pairs',
+                                  xaxis_title='P-value',
+                                  yaxis_title='Asset Pairs',
+                                  yaxis=dict(autorange='reversed'))
+            st.plotly_chart(fig_bar)
+        except Exception as e:
+            st.error(f"Error: {str(e)}. Check ticker symbols or date range.")
+
     with st.expander("How it Works", expanded=False):
         st.markdown("""
         **Cointegration Overview:**
@@ -537,8 +528,6 @@ elif page == 'Pair Cointegration Identification':
         - The Johansen test is a more general procedure that allows for more than two series and can identify multiple cointegrating relationships.
         """)
 
-
-
 # Hide the default Streamlit menu and footer
 hide_streamlit_style = """
 <style>
@@ -546,4 +535,4 @@ hide_streamlit_style = """
 footer {visibility: hidden;}
 </style>
 """
-st.markdown(hide_streamlit_style, unsafe_allow_html=True)
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)