Update app.py

app.py

@@ -15,53 +15,35 @@ import shap
 import ta
 import matplotlib.pyplot as plt
 import warnings
-import colorsys
 import openai
 
 warnings.filterwarnings('ignore')
 
+# Initialize the OpenAI client
 OPENAI_API_KEY = "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"  # Replace with your actual OpenAI API key
 openai.api_key = OPENAI_API_KEY
 # Alpha Vantage API key
 ALPHA_VANTAGE_API_KEY = "JK0DVDNTEYBTBP5L"
 
-def adjust_color_intensity(base_color, percentage):
-    r = int(base_color[1:3], 16) / 255.0
-    g = int(base_color[3:5], 16) / 255.0
-    b = int(base_color[5:7], 16) / 255.0
-    
-    h, l, s = colorsys.rgb_to_hls(r, g, b)
-    
-    l = max(0, min(1, l - (abs(percentage) / 100 * 0.5)))
-    
-    r, g, b = colorsys.hls_to_rgb(h, l, s)
-    
-    return f"#{int(r*255):02x}{int(g*255):02x}{int(b*255):02x}"
-
-def create_color_box(text, background_color, percentage):
-    adjusted_color = adjust_color_intensity(background_color, percentage)
-    return f"""
-    <div style="background-color: {adjusted_color}; padding: 20px; border-radius: 10px; margin-bottom: 20px; font-size: 16px; line-height: 1.6; display: flex; justify-content: space-between; align-items: center;">
-        <div style="flex: 1;">
-            {text}
-        </div>
-        <div style="flex: 0 0 40%; display: flex; justify-content: center; align-items: center;">
-            <div style="font-size: 72px; font-weight: bold; color: {'#006400' if percentage >= 0 else '#8B0000'};">
-                {'+' if percentage >= 0 else ''}{percentage:.2f}%
-            </div>
-        </div>
-    </div>
-    """
-
-def create_gradient_box(text, start_color, end_color, start_percentage, end_percentage):
-    adjusted_start_color = adjust_color_intensity(start_color, start_percentage)
-    adjusted_end_color = adjust_color_intensity(end_color, end_percentage)
-    return f"""
-    <div style="background: linear-gradient(to right, {adjusted_start_color}, {adjusted_end_color}); padding: 20px; border-radius: 10px; margin-bottom: 20px; font-size: 16px; line-height: 1.6;">
-        {text}
-    </div>
-    """
-
+# Custom CSS
+st.markdown("""
+<style>
+    .reportview-container .main .block-container {
+        max-width: 1200px;
+        padding-top: 2rem;
+        padding-bottom: 2rem;
+    }
+    .stAlert > div {
+        padding-top: 1rem;
+        padding-bottom: 1rem;
+    }
+    .stButton>button {
+        width: 100%;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+@st.cache_data
 def get_financial_data(ticker, end_date):
     base_url = "https://www.alphavantage.co/query"
     functions = ['INCOME_STATEMENT', 'BALANCE_SHEET', 'CASH_FLOW']
@@ -93,6 +75,7 @@ def get_financial_data(ticker, end_date):
 
     return data
 
+@st.cache_data
 def get_earnings_dates(ticker):
     url = f"https://www.alphavantage.co/query?function=EARNINGS&symbol={ticker}&apikey={ALPHA_VANTAGE_API_KEY}"
     response = requests.get(url)
@@ -106,6 +89,7 @@ def get_earnings_dates(ticker):
     
     return earnings_dates
 
+@st.cache_data
 def get_earnings_data(ticker):
     url = f"https://www.alphavantage.co/query?function=EARNINGS&symbol={ticker}&apikey={ALPHA_VANTAGE_API_KEY}"
     response = requests.get(url)
@@ -123,6 +107,7 @@ def get_earnings_data(ticker):
     
     return df
 
+@st.cache_data
 def process_financial_data(data, earnings_dates, earnings_data):
     quarterly_data = {}
 
@@ -146,6 +131,7 @@ def process_financial_data(data, earnings_dates, earnings_data):
 
     return df
 
+@st.cache_data
 def get_stock_data(ticker, start_date, end_date):
     df = yf.download(ticker, start=start_date, end=end_date)
     
@@ -170,8 +156,6 @@ def get_stock_data(ticker, start_date, end_date):
     return df
 
 def add_financial_ratios(X):
-    print("Adding financial ratios...")
-    
     def safe_divide(a, b):
         return np.where(b != 0, a / b, np.nan)
     
@@ -181,14 +165,9 @@ def add_financial_ratios(X):
     X['ROE'] = safe_divide(X['INCOME_STATEMENT_netIncome'], X['BALANCE_SHEET_totalShareholderEquity'])
     X['ROA'] = safe_divide(X['INCOME_STATEMENT_netIncome'], X['BALANCE_SHEET_totalAssets'])
     
-    print("Financial ratios added.")
     return X
 
 def prepare_data(quarterly_df, stock_df, end_date):
-    print("Starting data preparation...")
-    print(f"Initial quarterly_df shape: {quarterly_df.shape}")
-    print(f"Initial stock_df shape: {stock_df.shape}")
-
     quarterly_df.index = pd.to_datetime(quarterly_df.index).date
     stock_df.index = pd.to_datetime(stock_df.index).date
 
@@ -205,8 +184,6 @@ def prepare_data(quarterly_df, stock_df, end_date):
 
     merged_df = merged_df.dropna(subset=['Close'])
 
-    print(f"Merged dataframe shape: {merged_df.shape}")
-
     if merged_df.empty:
         raise ValueError("No overlapping data between stock prices and financial statements.")
 
@@ -226,9 +203,6 @@ def prepare_data(quarterly_df, stock_df, end_date):
     X_scaled = pd.DataFrame(scaler_X.fit_transform(X), columns=X.columns, index=X.index)
     y_scaled = pd.Series(scaler_y.fit_transform(y.values.reshape(-1, 1)).flatten(), index=y.index)
 
-    print(f"Final data shape: X: {X_scaled.shape}, y: {y_scaled.shape}")
-    print(f"Date range: {X_scaled.index.min()} to {X_scaled.index.max()}")
-
     return X_scaled, y_scaled, merged_df.index, scaler_X, scaler_y
 
 def train_catboost_model(X_train, X_test, y_train, y_test):
@@ -250,8 +224,6 @@ def evaluate_model(model, X_test, y_test, scaler_y):
 
     mse = mean_squared_error(y_test_unscaled, y_pred)
     r2 = r2_score(y_test_unscaled, y_pred)
-    print(f"Mean Squared Error: {mse}")
-    print(f"R-squared Score: {r2}")
     return r2
 
 def conformal_prediction(model, X_train, y_train, X_test, scaler_y, alpha=0.1):
@@ -293,6 +265,7 @@ def plot_results(dates, y, fair_values, lower_bound, upper_bound, scaler_y):
 
     return fig
 
+@st.cache_data
 def get_monthly_seasonality(ticker, start_date, end_date):
     data = yf.download(ticker, start=start_date, end=end_date)
     monthly_data = data['Adj Close'].resample('M').last()
@@ -374,7 +347,7 @@ def get_gpt_analysis(ticker, financial_data):
         analysis = response.choices[0].message['content'].strip()
         return analysis
     except Exception as e:
-        print(f"OpenAI API error: {e}")
+        st.error(f"OpenAI API error: {e}")
         return "GPT Assistant analysis failed. Please check the API integration."
 
 def plot_interactive_logarithmic_stock_chart(ticker, start_date, end_date):
@@ -432,135 +405,76 @@ def plot_interactive_logarithmic_stock_chart(ticker, start_date, end_date):
     return fig
 
 def analyze_stock(ticker, start_date, end_date, use_ai_assistant):
-    try:
-        print(f"Starting analysis for {ticker} from {start_date} to {end_date}")
-
-        end_date_dt = end_date
-
-        print("Fetching financial data...")
-        financial_data = get_financial_data(ticker, end_date_dt)
-        print("Fetching earnings dates...")
-        earnings_dates = get_earnings_dates(ticker)
-        print("Fetching earnings data...")
-        earnings_data = get_earnings_data(ticker)
-        print("Processing financial data...")
-        quarterly_df = process_financial_data(financial_data, earnings_dates, earnings_data)
-        print("Downloading stock data...")
-        stock_df = get_stock_data(ticker, start_date, end_date)
-
-        if quarterly_df.empty:
-            return "No financial data available for processing.", None, None, None, None, None, None, None, None
-
-        print(f"Quarterly data shape: {quarterly_df.shape}")
-        print(f"Stock data shape: {stock_df.shape}")
-
-        print("Preparing data for analysis...")
-        X_scaled, y_scaled, dates, scaler_X, scaler_y = prepare_data(quarterly_df, stock_df, end_date_dt)
-
-        if X_scaled is None or y_scaled is None:
-            return "Not enough data for model training.", None, None, None, None, None, None, None, None
-
-        print(f"Prepared data shape: X: {X_scaled.shape}, y: {y_scaled.shape}")
-        print(f"X column names: {X_scaled.columns.tolist()}")
+    with st.spinner('Analyzing stock data...'):
+        try:
+            financial_data = get_financial_data(ticker, end_date)
+            earnings_dates = get_earnings_dates(ticker)
+            earnings_data = get_earnings_data(ticker)
+            quarterly_df = process_financial_data(financial_data, earnings_dates, earnings_data)
+            stock_df = get_stock_data(ticker, start_date, end_date)
+
+            if quarterly_df.empty:
+                st.error("No financial data available for processing.")
+                return
+
+            X_scaled, y_scaled, dates, scaler_X, scaler_y = prepare_data(quarterly_df, stock_df, end_date)
+
+            X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_scaled, test_size=0.2, random_state=42)
+
+            model = train_catboost_model(X_train, X_test, y_train, y_test)
+            
+            r2 = evaluate_model(model, X_test, y_test, scaler_y)
+
+            if r2 < 0.5:
+                st.warning("Model performance is poor. Results may not be reliable.")
+
+            fair_values, lower_bound, upper_bound = conformal_prediction(model, X_train, y_train, X_scaled, scaler_y)
+
+            fig = plot_results(dates, y_scaled, fair_values, lower_bound, upper_bound, scaler_y)
+
+            feature_importance = model.feature_importances_
+            feature_importance_df = pd.DataFrame({'feature': X_scaled.columns, 'importance': feature_importance})
+            feature_importance_df = feature_importance_df.sort_values('importance', ascending=False)
+
+            explainer = shap.TreeExplainer(model)
+            shap_values = explainer.shap_values(X_scaled)
+
+            shap_fig, ax = plt.subplots(figsize=(10, 6))
+            shap.summary_plot(shap_values, X_scaled, plot_type="bar", show=False)
+            plt.title("SHAP Feature Importance")
+            plt.tight_layout()
+
+            seasonality = get_monthly_seasonality(ticker, start_date, end_date)
+            seasonality_fig = plot_monthly_seasonality(seasonality, ticker, start_date, end_date)
+
+            log_chart = plot_interactive_logarithmic_stock_chart(ticker, start_date, end_date)
+
+            gpt_analysis = get_gpt_analysis(ticker, financial_data) if use_ai_assistant else "AI assistant analysis not requested."
+
+            return {
+                'ticker': ticker,
+                'fair_values': fair_values,
+                'lower_bound': lower_bound,
+                'upper_bound': upper_bound,
+                'r2': r2,
+                'fig': fig,
+                'feature_importance_df': feature_importance_df,
+                'shap_fig': shap_fig,
+                'seasonality': seasonality,
+                'seasonality_fig': seasonality_fig,
+                'gpt_analysis': gpt_analysis,
+                'log_chart': log_chart,
+                'latest_close': stock_df['Close'].iloc[-1],
+                'latest_fair_value': fair_values[-1],
+                'latest_lower_bound': lower_bound[-1],
+                'latest_upper_bound': upper_bound[-1],
+            }
+
+        except Exception as e:
+            st.error(f"An error occurred: {str(e)}")
+            return None
 
-        print(f"Final number of features: {X_scaled.shape[1]}")
-        print("Data prepared successfully. Starting model training...")
-
-        X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_scaled, test_size=0.2, random_state=42)
-
-        print("Training CatBoost model...")
-        model = train_catboost_model(X_train, X_test, y_train, y_test)
-        
-        print("Evaluating model performance...")
-        r2 = evaluate_model(model, X_test, y_test, scaler_y)
-
-        if r2 < 0.5:
-            return "Model performance is poor. Re-evaluate features or model parameters.", None, None, None, None, None, None, None, None
-
-        print("Model trained successfully. Calculating fair values with conformal prediction...")
-        fair_values, lower_bound, upper_bound = conformal_prediction(model, X_train, y_train, X_scaled, scaler_y)
-
-        print("Plotting results...")
-        fig = plot_results(dates, y_scaled, fair_values, lower_bound, upper_bound, scaler_y)
-
-        print("Calculating feature importance...")
-        feature_importance = model.feature_importances_
-        feature_importance_df = pd.DataFrame({'feature': X_scaled.columns, 'importance': feature_importance})
-        feature_importance_df = feature_importance_df.sort_values('importance', ascending=False)
-        print("\nTop 10 most important features:")
-        print(feature_importance_df.head(10))
-
-        print("\nCalculating SHAP values for feature importance...")
-        explainer = shap.TreeExplainer(model)
-        shap_values = explainer.shap_values(X_scaled)
-
-        shap_fig = plt.figure(figsize=(10, 6))
-        shap.summary_plot(shap_values, X_scaled, plot_type="bar", show=False)
-        plt.title("SHAP Feature Importance")
-        plt.tight_layout()
-
-        seasonality = get_monthly_seasonality(ticker, start_date, end_date)
-        seasonality_fig = plot_monthly_seasonality(seasonality, ticker, start_date, end_date)
-
-        current_month = datetime.now().month
-        next_month = (current_month % 12) + 1
-
-        current_month_return = seasonality.loc[current_month, 'Mean Change%'] * 100
-        next_month_return = seasonality.loc[next_month, 'Mean Change%'] * 100
-        current_month_win_rate = seasonality.loc[current_month, 'Positive Periods'] * 100
-        next_month_win_rate = seasonality.loc[next_month, 'Positive Periods'] * 100
-
-        seasonality_text = f"""
-        <h2 style="margin-bottom: 15px;">Seasonality Analysis ({start_date} to {end_date})</h2>
-        <h3>Current month ({datetime.now().strftime('%B')}):</h3>
-        <p>Average return: {current_month_return:.2f}%</p>
-        <p>Probability of positive return: {current_month_win_rate:.1f}%</p>
-        <h3>Next month ({(datetime.now() + timedelta(days=31)).strftime('%B')}):</h3>
-        <p>Average return: {next_month_return:.2f}%</p>
-        <p>Probability of positive return: {next_month_win_rate:.1f}%</p>
-        """
-
-        latest_close = stock_df['Close'].iloc[-1]
-        latest_fair_value = fair_values[-1]
-        latest_lower_bound = lower_bound[-1]
-        latest_upper_bound = upper_bound[-1]
-
-        fair_price_text = f"""
-        <h2 style="margin-bottom: 15px;">Fair Price Analysis</h2>
-        <p><strong>Current Price:</strong> ${latest_close:.2f}</p>
-        <p><strong>Estimated Fair Value:</strong> ${latest_fair_value:.2f}</p>
-        <p><strong>Price Prediction Range:</strong> ${latest_lower_bound:.2f} to ${latest_upper_bound:.2f}</p>
-        <p><strong>R-squared Score:</strong> {r2:.4f}</p>
-        <h3 style="margin-top: 20px;">Top 10 most important features for fair value prediction:</h3>
-        <pre>{feature_importance_df.head(10).to_string(index=False)}</pre>
-        """
-
-        # Determine background color and percentage change
-        percentage_change = ((latest_fair_value - latest_close) / latest_close) * 100
-        background_color = "#d4edda" if percentage_change > 0 else "#f8d7da"
-        fair_price_html = create_color_box(fair_price_text, background_color, percentage_change)
-
-        # Format the seasonality analysis results
-        current_month_color = "#d4edda" if current_month_return > 0 else "#f8d7da"
-        next_month_color = "#d4edda" if next_month_return > 0 else "#f8d7da"
-        seasonality_html = create_gradient_box(seasonality_text, current_month_color, next_month_color, current_month_return, next_month_return)
-
-        # Generate logarithmic chart
-        log_chart = plot_interactive_logarithmic_stock_chart(ticker, start_date, end_date)
-
-        # Get GPT analysis if requested
-        gpt_analysis = get_gpt_analysis(ticker, financial_data) if use_ai_assistant else "AI assistant analysis not requested."
-
-        return fair_price_html, fig, shap_fig, seasonality_fig, seasonality_html, gpt_analysis, log_chart
-
-    except Exception as e:
-        error_message = f"An error occurred: {str(e)}"
-        print(error_message)
-        return error_message, None, None, None, None, None, None
-
-# Streamlit app
 def main():
-    st.set_page_config(page_title="Advanced Stock Analysis", layout="wide")
     st.title("Advanced Stock Analysis App")
     st.markdown("Enter a stock ticker and date range to perform comprehensive stock analysis.")
 
@@ -572,42 +486,57 @@ def main():
     with col3:
         end_date = st.date_input("End Date", value=datetime.now())
 
-    use_ai_assistant = st.checkbox("Use AI Assistant")
-
-    if st.button("Submit", type="primary"):
-        with st.spinner("Analyzing..."):
-            results = analyze_stock(ticker, start_date, end_date, use_ai_assistant)
-            display_results(results)
-
-def display_results(results):
-    if isinstance(results, str):  # Error occurred
-        st.error(results)
-        return
-
-    fair_price_html, fig, shap_fig, seasonality_fig, seasonality_html, gpt_analysis, log_chart = results
+    use_ai_assistant = st.checkbox("Use AI Assistant for Analysis")
 
-    st.subheader("Fair Price Analysis")
-    st.markdown(fair_price_html, unsafe_allow_html=True)
-
-    st.subheader("Fair Price Prediction")
-    st.plotly_chart(fig, use_container_width=True)
-
-    col1, col2 = st.columns(2)
-    with col1:
-        st.subheader("SHAP Feature Importance")
-        st.pyplot(shap_fig)
-    with col2:
-        st.subheader("Monthly Seasonality")
-        st.plotly_chart(seasonality_fig, use_container_width=True)
-
-    st.markdown(seasonality_html, unsafe_allow_html=True)
-
-    if gpt_analysis != "AI assistant analysis not requested.":
-        st.subheader("GPT Assistant Analysis")
-        st.text_area("Analysis", value=gpt_analysis, height=300)
-
-    st.subheader("Logarithmic Stock Chart")
-    st.plotly_chart(log_chart, use_container_width=True)
+    if st.button("Analyze Stock"):
+        results = analyze_stock(ticker, start_date, end_date, use_ai_assistant)
+        
+        if results:
+            st.subheader("Fair Price Analysis")
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric("Current Price", f"${results['latest_close']:.2f}")
+            with col2:
+                st.metric("Estimated Fair Value", f"${results['latest_fair_value']:.2f}", 
+                          f"{((results['latest_fair_value'] - results['latest_close']) / results['latest_close'] * 100):.2f}%")
+            with col3:
+                st.metric("R-squared Score", f"{results['r2']:.4f}")
+
+            st.metric("Price Prediction Range", 
+                      f"${results['latest_lower_bound']:.2f} to ${results['latest_upper_bound']:.2f}")
+
+            st.subheader("Fair Price Prediction")
+            st.plotly_chart(results['fig'], use_container_width=True)
+
+            col1, col2 = st.columns(2)
+            with col1:
+                st.subheader("SHAP Feature Importance")
+                st.pyplot(results['shap_fig'])
+            with col2:
+                st.subheader("Top 10 Important Features")
+                st.dataframe(results['feature_importance_df'].head(10))
+
+            st.subheader("Monthly Seasonality")
+            st.plotly_chart(results['seasonality_fig'], use_container_width=True)
+
+            current_month = datetime.now().month
+            next_month = (current_month % 12) + 1
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric(f"Current month ({datetime.now().strftime('%B')})", 
+                          f"{results['seasonality'].loc[current_month, 'Mean Change%']*100:.2f}%",
+                          f"{results['seasonality'].loc[current_month, 'Positive Periods']*100:.1f}% probability of positive return")
+            with col2:
+                st.metric(f"Next month ({(datetime.now() + timedelta(days=31)).strftime('%B')})",
+                          f"{results['seasonality'].loc[next_month, 'Mean Change%']*100:.2f}%",
+                          f"{results['seasonality'].loc[next_month, 'Positive Periods']*100:.1f}% probability of positive return")
+
+            if results['gpt_analysis'] != "AI assistant analysis not requested.":
+                st.subheader("AI Assistant Analysis")
+                st.text_area("Analysis", value=results['gpt_analysis'], height=300)
+
+            st.subheader("Logarithmic Stock Chart")
+            st.plotly_chart(results['log_chart'], use_container_width=True)
 
 if __name__ == "__main__":
     main()