Create app.py

app.py

@@ -0,0 +1,618 @@
+import streamlit as st
+import yfinance as yf
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from datetime import datetime, timedelta
+import requests
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error, r2_score
+from sklearn.preprocessing import StandardScaler
+from catboost import CatBoostRegressor
+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 = st.secrets["OPENAI_API_KEY"]
+openai.api_key = OPENAI_API_KEY
+
+# Alpha Vantage API key
+ALPHA_VANTAGE_API_KEY = st.secrets["ALPHA_VANTAGE_API_KEY"]
+
+# GPT Assistant ID
+ASSISTANT_ID = st.secrets["ASSISTANT_ID"]
+
+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>
+    """
+
+def get_financial_data(ticker, end_date):
+    base_url = "https://www.alphavantage.co/query"
+    functions = ['INCOME_STATEMENT', 'BALANCE_SHEET', 'CASH_FLOW']
+    data = {}
+
+    for function in functions:
+        params = {
+            "function": function,
+            "symbol": ticker,
+            "apikey": ALPHA_VANTAGE_API_KEY
+        }
+        response = requests.get(base_url, params=params)
+        if response.status_code == 200:
+            data[function] = response.json()
+        else:
+            raise Exception(f"Failed to fetch {function} data: {response.status_code}")
+
+    for function, content in data.items():
+        if 'quarterlyReports' in content:
+            content['quarterlyReports'] = [
+                report for report in content['quarterlyReports']
+                if datetime.strptime(report['fiscalDateEnding'], '%Y-%m-%d').date() <= end_date
+            ]
+        if 'annualReports' in content:
+            content['annualReports'] = [
+                report for report in content['annualReports']
+                if datetime.strptime(report['fiscalDateEnding'], '%Y-%m-%d').date() <= end_date
+            ]
+
+    return 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)
+    data = response.json()
+    
+    earnings_dates = {}
+    for report in data.get('quarterlyEarnings', []):
+        fiscal_date = report['fiscalDateEnding']
+        reported_date = report['reportedDate']
+        earnings_dates[fiscal_date] = reported_date
+    
+    return earnings_dates
+
+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)
+    data = response.json()
+    
+    quarterly_earnings = data.get('quarterlyEarnings', [])
+    df = pd.DataFrame(quarterly_earnings)
+    df['fiscalDateEnding'] = pd.to_datetime(df['fiscalDateEnding'])
+    df['reportedDate'] = pd.to_datetime(df['reportedDate'])
+    df = df.set_index('reportedDate')
+    
+    numeric_columns = ['reportedEPS', 'estimatedEPS', 'surprise', 'surprisePercentage']
+    for col in numeric_columns:
+        df[col] = pd.to_numeric(df[col], errors='coerce')
+    
+    return df
+
+def process_financial_data(data, earnings_dates, earnings_data):
+    quarterly_data = {}
+
+    for statement_type, statement_data in data.items():
+        if 'quarterlyReports' in statement_data:
+            for report in statement_data['quarterlyReports']:
+                fiscal_date = report['fiscalDateEnding']
+                release_date = earnings_dates.get(fiscal_date, fiscal_date)
+                if release_date not in quarterly_data:
+                    quarterly_data[release_date] = {}
+                quarterly_data[release_date].update({f"{statement_type}_{k}": v for k, v in report.items()})
+
+    df = pd.DataFrame.from_dict(quarterly_data, orient='index')
+    df.index = pd.to_datetime(df.index)
+    df = df.sort_index()
+
+    df = df.join(earnings_data, how='left')
+
+    for col in df.columns:
+        df[col] = pd.to_numeric(df[col], errors='coerce')
+
+    return df
+
+def get_stock_data(ticker, start_date, end_date):
+    df = yf.download(ticker, start=start_date, end=end_date)
+    
+    df['Price_Pct_Change'] = df['Close'].pct_change()
+    
+    df['RSI'] = ta.momentum.RSIIndicator(df['Close']).rsi()
+    df['WILLR'] = ta.momentum.WilliamsRIndicator(df['High'], df['Low'], df['Close']).williams_r()
+    bb = ta.volatility.BollingerBands(df['Close'])
+    df['BB_upper'] = bb.bollinger_hband()
+    df['BB_middle'] = bb.bollinger_mavg()
+    df['BB_lower'] = bb.bollinger_lband()
+    df['OBV'] = ta.volume.OnBalanceVolumeIndicator(df['Close'], df['Volume']).on_balance_volume()
+    df['ATR'] = ta.volatility.AverageTrueRange(df['High'], df['Low'], df['Close']).average_true_range()
+    df['MACD'] = ta.trend.MACD(df['Close']).macd()
+    df['ADX'] = ta.trend.ADXIndicator(df['High'], df['Low'], df['Close']).adx()
+    df['CCI'] = ta.trend.CCIIndicator(df['High'], df['Low'], df['Close']).cci()
+    
+    indicator_columns = ['RSI', 'WILLR', 'BB_upper', 'BB_middle', 'BB_lower', 'OBV', 'ATR', 'MACD', 'ADX', 'CCI']
+    for column in indicator_columns:
+        df[f'{column}_ROC'] = df[column].pct_change()
+    
+    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)
+    
+    X['PE_Ratio'] = safe_divide(X['BALANCE_SHEET_totalShareholderEquity'], X['INCOME_STATEMENT_netIncome'])
+    X['PB_Ratio'] = safe_divide(X['BALANCE_SHEET_totalAssets'], X['BALANCE_SHEET_totalShareholderEquity'])
+    X['Debt_to_Equity'] = safe_divide(X['BALANCE_SHEET_totalLiabilities'], X['BALANCE_SHEET_totalShareholderEquity'])
+    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
+
+    quarterly_df = quarterly_df[quarterly_df.index <= end_date]
+    stock_df = stock_df[stock_df.index <= end_date]
+
+    start_date = min(quarterly_df.index.min(), stock_df.index.min())
+    all_dates = pd.date_range(start=start_date, end=end_date, freq='D').date
+
+    quarterly_df_reindexed = quarterly_df.reindex(all_dates).ffill()
+    stock_df_reindexed = stock_df.reindex(all_dates).ffill()
+
+    merged_df = pd.concat([stock_df_reindexed['Close'], quarterly_df_reindexed], axis=1)
+
+    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.")
+
+    X = merged_df.drop('Close', axis=1)
+    y = merged_df['Close']
+
+    X = X.fillna(X.mean())
+
+    X['EPS_Surprise'] = X['reportedEPS'] - X['estimatedEPS']
+    X['EPS_Surprise_Percentage'] = X['surprisePercentage']
+
+    X = add_financial_ratios(X)
+
+    scaler_X = StandardScaler()
+    scaler_y = StandardScaler()
+
+    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):
+    model = CatBoostRegressor(
+        iterations=1000,
+        learning_rate=0.1,
+        depth=6,
+        loss_function='RMSE',
+        random_state=42,
+        verbose=100
+    )
+    model.fit(X_train, y_train, eval_set=(X_test, y_test), early_stopping_rounds=50)
+    return model
+
+def evaluate_model(model, X_test, y_test, scaler_y):
+    y_pred_scaled = model.predict(X_test)
+    y_pred = scaler_y.inverse_transform(y_pred_scaled.reshape(-1, 1)).flatten()
+    y_test_unscaled = scaler_y.inverse_transform(y_test.values.reshape(-1, 1)).flatten()
+
+    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):
+    model.fit(X_train, y_train)
+    y_pred_train = model.predict(X_train)
+
+    y_pred_train_unscaled = scaler_y.inverse_transform(y_pred_train.reshape(-1, 1)).flatten()
+    y_train_unscaled = scaler_y.inverse_transform(y_train.values.reshape(-1, 1)).flatten()
+
+    relative_errors = np.abs((y_train_unscaled - y_pred_train_unscaled) / y_pred_train_unscaled)
+
+    error_threshold = np.percentile(relative_errors, (1 - alpha) * 100)
+
+    y_pred_test = model.predict(X_test)
+    y_pred_test_unscaled = scaler_y.inverse_transform(y_pred_test.reshape(-1, 1)).flatten()
+
+    lower_bound_unscaled = y_pred_test_unscaled * (1 - error_threshold)
+    upper_bound_unscaled = y_pred_test_unscaled * (1 + error_threshold)
+
+    return y_pred_test_unscaled, lower_bound_unscaled, upper_bound_unscaled
+
+def plot_results(dates, y, fair_values, lower_bound, upper_bound, scaler_y):
+    y_unscaled = scaler_y.inverse_transform(y.values.reshape(-1, 1)).flatten()
+
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.02, row_heights=[0.7, 0.3])
+
+    fig.add_trace(go.Scatter(x=dates, y=y_unscaled, mode='lines', name='Actual Price', line=dict(color='blue')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=dates, y=fair_values, mode='lines', name='Fair Value', line=dict(color='red')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=dates, y=upper_bound, mode='lines', name='Upper Bound', line=dict(color='gray', width=0)), row=1, col=1)
+    fig.add_trace(go.Scatter(x=dates, y=lower_bound, mode='lines', name='Lower Bound', line=dict(color='gray', width=0), fill='tonexty'), row=1, col=1)
+
+    percent_error = ((fair_values - y_unscaled) / y_unscaled) * 100
+    fig.add_trace(go.Scatter(x=dates, y=percent_error, mode='lines', name='Percent Error', line=dict(color='purple')), row=2, col=1)
+
+    fig.update_layout(height=800, title_text="Stock Price, Fair Value, and Percent Error")
+    fig.update_xaxes(title_text="Date", row=2, col=1)
+    fig.update_yaxes(title_text="Price", row=1, col=1)
+    fig.update_yaxes(title_text="Percent Error", row=2, col=1)
+
+    return fig
+
+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()
+    monthly_returns = monthly_data.pct_change()
+    monthly_returns = monthly_returns.to_frame()
+    monthly_returns['Month'] = monthly_returns.index.month
+    seasonality = monthly_returns.groupby('Month')['Adj Close'].agg(['mean', 'median', 'count', lambda x: (x > 0).mean()])
+    seasonality.columns = ['Mean Change%', 'Median Change%', 'Count', 'Positive Periods']
+    return seasonality
+
+def plot_monthly_seasonality(seasonality, ticker, start_date, end_date):
+    months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+    fig = go.Figure()
+    fig.add_trace(go.Bar(
+        x=months,
+        y=seasonality['Positive Periods'] * 100,
+        name='Positive Periods',
+        marker_color=['green' if x > 0.5 else 'red' for x in seasonality['Positive Periods']],
+        text=[f"{seasonality['Positive Periods'][i]*100:.1f}%<br>{seasonality['Mean Change%'][i]*100:.2f}%" for i in range(1, 13)],
+        textposition='auto'
+    ))
+    fig.add_trace(go.Scatter(
+        x=months,
+        y=seasonality['Mean Change%'] * 100,
+        name='Mean Change%',
+        mode='lines+markers',
+        line=dict(color='yellow', width=2)
+    ))
+    fig.update_layout(
+        title=f'Monthly Seasonality for {ticker}<br>{start_date} to {end_date}',
+        xaxis_title='Month',
+        yaxis_title='Percentage',
+        template='plotly_dark',
+        showlegend=True,
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+        height=600,
+        margin=dict(l=50, r=50, t=100, b=50)
+    )
+    fig.add_hline(y=50, line_dash="dash", line_color="gray")
+    fig.add_hline(y=0, line_dash="dash", line_color="gray")
+    fig.update_yaxes(ticksuffix="%", range=[0, 100])
+    return fig
+
+def prepare_financial_data_for_gpt(financial_data):
+    def format_financial_data(data, report_type):
+        formatted_data = f"{report_type} (Last 5 Years):\n"
+        if report_type in data:
+            reports = data[report_type].get('annualReports', [])[:5]
+            for report in reports:
+                formatted_data += f"Fiscal Date Ending: {report.get('fiscalDateEnding', 'N/A')}\n"
+                for key, value in report.items():
+                    if key != 'fiscalDateEnding':
+                        formatted_data += f"{key}: {value}\n"
+                formatted_data += "\n"
+        return formatted_data
+
+    income_statement = format_financial_data(financial_data, 'INCOME_STATEMENT')
+    balance_sheet = format_financial_data(financial_data, 'BALANCE_SHEET')
+    cash_flow = format_financial_data(financial_data, 'CASH_FLOW')
+
+    return f"{income_statement}\n{balance_sheet}\n{cash_flow}"
+
+def get_gpt_analysis(ticker, financial_data):
+    formatted_data = prepare_financial_data_for_gpt(financial_data)
+    prompt = f"Analyze the following financial data for {ticker} and provide insights:\n\n{formatted_data}"
+    
+    try:
+        response = openai.ChatCompletion.create(
+            model="gpt-4",
+            messages=[
+                {"role": "system", "content": "You are a financial analyst."},
+                {"role": "user", "content": prompt}
+            ],
+            max_tokens=500,
+            n=1,
+            stop=None,
+            temperature=0.5,
+        )
+        analysis = response.choices[0].message['content'].strip()
+        return analysis
+    except Exception as e:
+        print(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):
+    stock = yf.Ticker(ticker)
+    data = stock.history(start=start_date, end=end_date)
+
+    x = (data.index - data.index[0]).days
+    y = np.log(data['Close'])
+    slope, intercept = np.polyfit(x, y, 1)
+
+    future_days = 365 * 10
+    all_days = np.arange(len(x) + future_days)
+    log_trend = np.exp(intercept + slope * all_days)
+
+    inner_upper_band = log_trend * 2
+    inner_lower_band = log_trend / 2
+    outer_upper_band = log_trend * 4
+    outer_lower_band = log_trend / 4
+
+    extended_dates = pd.date_range(start=data.index[0], periods=len(all_days), freq='D')
+
+    fig = go.Figure()
+
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='blue')))
+
+    fig.add_trace(go.Scatter(x=extended_dates, y=log_trend, mode='lines', name='Log Trend', line=dict(color='red')))
+    fig.add_trace(go.Scatter(x=extended_dates, y=inner_upper_band, mode='lines', name='Inner Upper Band', line=dict(color='green')))
+    fig.add_trace(go.Scatter(x=extended_dates, y=inner_lower_band, mode='lines', name='Inner Lower Band', line=dict(color='green')))
+    fig.add_trace(go.Scatter(x=extended_dates, y=outer_upper_band, mode='lines', name='Outer Upper Band', line=dict(color='orange')))
+    fig.add_trace(go.Scatter(x=extended_dates, y=outer_lower_band, mode='lines', name='Outer Lower Band', line=dict(color='orange')))
+
+    fig.update_layout(
+        title=f'{ticker} Stock Price (Logarithmic Scale) with Extended Trend Lines and Outer Bands',
+        xaxis_title='Date',
+        yaxis_title='Price (Log Scale)',
+        yaxis_type="log",
+        legend=dict(x=0.01, y=0.99, bgcolor='rgba(255, 255, 255, 0.8)'),
+        hovermode='x unified',
+        height=800
+    )
+
+    fig.update_xaxes(
+        rangeslider_visible=True,
+        rangeselector=dict(
+            buttons=list([
+                dict(count=1, label="1m", step="month", stepmode="backward"),
+                dict(count=6, label="6m", step="month", stepmode="backward"),
+                dict(count=1, label="YTD", step="year", stepmode="todate"),
+                dict(count=1, label="1y", step="year", stepmode="backward"),
+                dict(step="all")
+            ])
+        )
+    )
+
+    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()}")
+
+        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.")
+
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        ticker = st.text_input("Stock Ticker", value="MSFT")
+    with col2:
+        start_date = st.date_input("Start Date", value=datetime(2015, 1, 1))
+    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
+
+    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 __name__ == "__main__":
+    main()