Create app.py

app.py

@@ -0,0 +1,595 @@
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+import streamlit as st
+from datetime import timedelta
+from scipy.stats import norm
+
+# Define functions
+
+def fetch_earnings_data(ticker, limit=99):
+    msft = yf.Ticker(ticker)
+    earnings_dates = msft.get_earnings_dates(limit=limit)
+    earnings_dates.index = earnings_dates.index.tz_localize(None)
+    earnings_dates = earnings_dates.dropna(subset=['EPS Estimate'])
+    return earnings_dates
+
+def fetch_stock_data(ticker, start_date, end_date, buffer_days):
+    start_date = start_date - pd.Timedelta(days=buffer_days)
+    end_date = end_date + pd.Timedelta(days=buffer_days)
+    stock_data = yf.download(ticker, start=start_date, end=end_date)
+    stock_data.index = stock_data.index.tz_localize(None)
+    return stock_data
+
+def calculate_metrics(stock_data):
+    stock_data['Returns'] = stock_data['Close'].pct_change()
+    stock_data['20D Volatility'] = stock_data['Returns'].rolling(window=20).std()
+    return stock_data
+
+def plot_stock_price_with_earnings(stock_data, earnings_dates, ticker):
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=stock_data.index, y=stock_data['Close'], mode='lines', name='Stock Price', line=dict(color='blue')))
+    scaling_factor = 150
+    max_marker_size = 100  # Limit the maximum marker size
+    added_positive_legend = False
+    added_negative_legend = False
+
+    for index, row in earnings_dates.iterrows():
+        date = index
+        if date not in stock_data.index:
+            date = stock_data.index[stock_data.index.get_indexer([date], method='nearest')[0]]
+        
+        surprise = row['Surprise(%)']
+        marker_size = abs(surprise) * scaling_factor if not np.isnan(surprise) else 10  # Default size if NaN
+        marker_size = min(marker_size, max_marker_size)  # Cap the marker size
+        
+        color = 'green' if surprise > 0 else 'red'
+        marker = '^' if surprise > 0 else 'v'
+
+        if surprise > 0:
+            name = 'Positive EPS Surprise' if not added_positive_legend else None
+            added_positive_legend = True
+        else:
+            name = 'Negative EPS Surprise' if not added_negative_legend else None
+            added_negative_legend = True
+
+        fig.add_trace(go.Scatter(x=[date], y=[stock_data.loc[date, 'Close']], mode='markers', 
+                                 marker=dict(symbol='triangle-up' if marker == '^' else 'triangle-down', size=10 if name is not None else marker_size, color=color), 
+                                 name=name, showlegend=name is not None))
+
+    fig.update_layout(title=f'{ticker} Stock Price with Earnings Surprise', 
+                      xaxis_title='Date', yaxis_title='Stock Price', 
+                      legend_title='Legend', template='plotly_white', 
+                      height=600, width=1200)
+    return fig
+
+def ensure_window_size(subset, earning_date, pre_announcement_window, post_announcement_window):
+    expected_dates = [earning_date + pd.Timedelta(days=i) for i in range(-pre_announcement_window, post_announcement_window + 1)]
+    for expected_date in expected_dates:
+        if expected_date not in subset.index:
+            subset.loc[expected_date] = np.nan
+    return subset.sort_index()
+
+def plot_normalized_price_movements(stock_data, earnings_dates, ticker, pre_announcement_window, post_announcement_window, upper_threshold, lower_threshold):
+    all_normalized_prices = []
+    for earning_date in earnings_dates.index:
+        start = earning_date - pd.Timedelta(days=pre_announcement_window)
+        end = earning_date + pd.Timedelta(days=post_announcement_window)
+        subset = stock_data.loc[start:end]['Close'].copy()
+        subset = ensure_window_size(subset, earning_date, pre_announcement_window, post_announcement_window)
+        subset.ffill(inplace=True)
+        subset.bfill(inplace=True)
+        subset = subset / subset[0]
+        all_normalized_prices.append(subset.tolist())
+
+    above_count = 0
+    below_count = 0
+    between_count = 0
+
+    for prices in all_normalized_prices:
+        if max(prices) > upper_threshold:
+            above_count += 1
+        elif min(prices) < lower_threshold:
+            below_count += 1
+        else:
+            between_count += 1
+
+    total_periods = len(all_normalized_prices)
+    prob_above = above_count / total_periods
+    prob_below = below_count / total_periods
+    prob_between = between_count / total_periods
+
+    latest_close_price = stock_data['Close'].iloc[-1]
+    actual_upper_threshold = latest_close_price * upper_threshold
+    actual_lower_threshold = latest_close_price * lower_threshold
+    window_days = list(range(-pre_announcement_window, post_announcement_window + 1))
+
+    fig = go.Figure()
+
+    for prices in all_normalized_prices:
+        if len(prices) == len(window_days):
+            fig.add_trace(go.Scatter(x=window_days, y=prices, mode='lines', line=dict(width=1), opacity=0.5, showlegend=False))
+
+    fig.add_hline(y=upper_threshold, line_dash="dash", line_color="green", annotation_text=f"+{(upper_threshold-1)*100:.2f}% Threshold (Price: {round(actual_upper_threshold, 2)})", annotation_position="top left")
+    fig.add_hline(y=lower_threshold, line_dash="dash", line_color="orange", annotation_text=f"-{(1-lower_threshold)*100:.2f}% Threshold (Price: {round(actual_lower_threshold, 2)})", annotation_position="bottom left")
+    fig.add_vline(x=0, line_dash="dash", line_color="red")
+
+    fig.update_layout(title=f"Normalized Price Movements Around Earnings Dates for {ticker}", xaxis_title="Days Relative to Earnings Date", yaxis_title="Normalized Price", legend_title="Legend", template='plotly_white', height=600, width=1200)
+    fig.add_trace(go.Scatter(x=[None], y=[None], mode='markers', marker=dict(size=10, color='white'), showlegend=True, name=f"Prob. Above +{(upper_threshold-1)*100:.2f}%: {prob_above:.2%}"))
+    fig.add_trace(go.Scatter(x=[None], y=[None], mode='markers', marker=dict(size=10, color='white'), showlegend=True, name=f"Prob. Below -{(1-lower_threshold)*100:.2%}: {prob_below:.2%}"))
+    fig.add_trace(go.Scatter(x=[None], y=[None], mode='markers', marker=dict(size=10, color='white'), showlegend=True, name=f"Prob. Between: {prob_between:.2%}"))
+
+    return fig
+
+def plot_volatility_around_earnings(stock_data, earnings_dates, window=5):
+    volatilities = []
+    for earnings_date in earnings_dates.index:
+        start_date = earnings_date - timedelta(days=window)
+        end_date = earnings_date + timedelta(days=window)
+        subset = stock_data.loc[start_date:end_date, '20D Volatility']
+        date_range = pd.date_range(start=start_date, end=end_date)
+        subset = subset.reindex(date_range, fill_value=np.nan).fillna(method='ffill').fillna(method='bfill')
+        normalized_volatility = subset - subset.iloc[0]
+        volatilities.append(normalized_volatility.values)
+
+    volatility_data = pd.DataFrame(volatilities, index=earnings_dates.index)
+    fig = go.Figure()
+
+    for i in range(volatility_data.shape[0]):
+        fig.add_trace(go.Scatter(x=np.arange(-5, 6), y=volatility_data.iloc[i], mode='lines', showlegend=False, line=dict(width=1)))
+
+    fig.add_shape(dict(type="line", x0=0, y0=volatility_data.min().min(), x1=0, y1=volatility_data.max().max(), line=dict(color="red", width=2, dash="dash")))
+    fig.update_layout(title='20-Day Rolling Volatility Around Earnings Announcements', xaxis_title='Days Relative to Earnings', yaxis_title='20-Day Volatility', xaxis=dict(tickmode='array', tickvals=np.arange(-5, 6, 1)), template='plotly_white')
+    return fig
+
+def plot_volume_around_earnings(stock_data, earnings_dates, window=5):
+    volumes = []
+    for earnings_date in earnings_dates.index:
+        start_date = earnings_date - timedelta(days=window)
+        end_date = earnings_date + timedelta(days=window)
+        subset = stock_data.loc[start_date:end_date, 'Volume']
+        date_range = pd.date_range(start=start_date, end=end_date)
+        subset = subset.reindex(date_range, fill_value=np.nan).fillna(method='ffill').fillna(method='bfill')
+        normalized_volume = subset - subset.iloc[0]
+        volumes.append(normalized_volume.values)
+
+    volume_data = pd.DataFrame(volumes, index=earnings_dates.index)
+    fig = go.Figure()
+
+    for i in range(volume_data.shape[0]):
+        fig.add_trace(go.Scatter(x=np.arange(-5, 6), y=volume_data.iloc[i], mode='lines', showlegend=False, line=dict(width=1)))
+
+    fig.add_shape(dict(type="line", x0=0, y0=volume_data.min().min(), x1=0, y1=volume_data.max().max(), line=dict(color="red", width=2, dash="dash")))
+    fig.update_layout(title='Reindexed Volume Around Earnings Announcements', xaxis_title='Days Relative to Earnings', yaxis_title='Reindexed Volume', xaxis=dict(tickmode='array', tickvals=np.arange(-5, 6, 1)), template='plotly_white')
+    return fig
+
+def compute_price_effect(earnings_date, stock_data):
+    try:
+        closest_date = stock_data.index[np.argmin(np.abs(stock_data.index - earnings_date))]
+        price_before_date = closest_date - pd.Timedelta(days=1)
+        price_on_date = closest_date
+        price_after_date = closest_date + pd.Timedelta(days=1)
+
+        price_before = stock_data.loc[:price_before_date, 'Close'].ffill().iloc[-1]
+        price_on = stock_data.loc[price_on_date, 'Close']
+        price_after = stock_data.loc[price_after_date:, 'Close'].bfill().iloc[0]
+
+        price_effect = ((price_after - price_before) / price_before) * 100
+
+        return price_before, price_on, price_after, price_effect
+    except (KeyError, IndexError) as e:
+        print(f"Missing data for date: {earnings_date} with error: {e}")
+        return None, None, None, None
+
+def plot_price_effects(earnings_dates):
+    latest_earnings_data = earnings_dates.sort_index(ascending=False).head(14).sort_index()
+    fig = go.Figure()
+    positions = list(range(len(latest_earnings_data)))
+    width = 0.25
+
+    fig.add_trace(go.Bar(x=[pos - width for pos in positions], y=latest_earnings_data['Price Before'], width=width, name='Price Before', marker_color='blue'))
+    fig.add_trace(go.Bar(x=positions, y=latest_earnings_data['Price On'], width=width, name='Price On', marker_color='cyan'))
+    fig.add_trace(go.Bar(x=[pos + width for pos in positions], y=latest_earnings_data['Price After'], width=width, name='Price After', marker_color='lightblue'))
+    fig.add_trace(go.Scatter(x=positions, y=latest_earnings_data['Surprise(%)'], mode='lines+markers+text', name='Surprise(%)', marker=dict(color='red', size=8), text=[f"{round(val, 2)}%" for val in latest_earnings_data['Surprise(%)']], textposition="top center", yaxis='y2'))
+    fig.add_trace(go.Scatter(x=positions, y=latest_earnings_data['Price Effect (%)'], mode='lines+markers+text', name='Price Effect (%)', marker=dict(color='green', size=8), text=[f"{round(val, 2)}%" for val in latest_earnings_data['Price Effect (%)']], textposition="top center", yaxis='y2'))
+
+    fig.update_layout(title='Earnings Data with Surprise and Price Effect', xaxis=dict(tickmode='array', tickvals=positions, ticktext=latest_earnings_data.index.strftime('%Y-%m-%d'), tickangle=45), barmode='group', yaxis=dict(title='Price', side='left'), yaxis2=dict(title='Percentage (%)', overlaying='y', side='right', tickmode='auto', nticks=10, range=[min(latest_earnings_data['Surprise(%)'].min(), latest_earnings_data['Price Effect (%)'].min()) - 5, max(latest_earnings_data['Surprise(%)'].max(), latest_earnings_data['Price Effect (%)'].max()) + 5]), legend=dict(x=0.01, y=0.99, bordercolor="Black", borderwidth=1), template='plotly_white')
+    return fig
+
+def plot_surprise_vs_price_effect(earnings_dates):
+    filtered_earnings_data = earnings_dates.dropna(subset=['Surprise(%)', 'Price Effect (%)'])
+    slope, intercept = np.polyfit(filtered_earnings_data['Surprise(%)'], filtered_earnings_data['Price Effect (%)'], 1)
+    x = np.array(filtered_earnings_data['Surprise(%)'])
+    y_pred = slope * x + intercept
+    correlation_matrix = np.corrcoef(filtered_earnings_data['Surprise(%)'], filtered_earnings_data['Price Effect (%)'])
+    correlation_xy = correlation_matrix[0, 1]
+    r_squared = correlation_xy**2
+
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=filtered_earnings_data['Surprise(%)'], y=filtered_earnings_data['Price Effect (%)'], mode='markers', marker=dict(color='blue', size=8), name='Data Points'))
+    fig.add_trace(go.Scatter(x=x, y=y_pred, mode='lines', line=dict(color='red'), name=f'y={slope:.3f}x + {intercept:.3f}'))
+    fig.update_layout(title='Earnings Surprise vs. Price Effect', xaxis_title='Earnings Surprise(%)', yaxis_title='Price Effect(%)', template='plotly_white', height=600, width=1200, showlegend=True)
+    fig.add_annotation(x=0.05, y=0.95, xref='paper', yref='paper', text=f'R-squared = {r_squared:.3f}', showarrow=False, font=dict(size=15, color='green'))
+    return fig
+
+def plot_price_ranges(ticker, implied_volatility, days_until_earnings, up_target, down_target, stock_data):
+    stock_price = stock_data['Close'].iloc[-1]
+    daily_iv = implied_volatility / np.sqrt(252)
+    days = np.arange(1, days_until_earnings + 1)
+    upper_bounds = []
+    lower_bounds = []
+    annotations = []
+
+    for day in days:
+        period_volatility = daily_iv * np.sqrt(day)
+        upper_bound = stock_price * (1 + period_volatility)
+        lower_bound = stock_price * (1 - period_volatility)
+        upper_bounds.append(upper_bound)
+        lower_bounds.append(lower_bound)
+        z_upper = (up_target - stock_price) / (stock_price * period_volatility)
+        z_lower = (down_target - stock_price) / (stock_price * period_volatility)
+        prob_above = 1 - norm.cdf(z_upper)
+        prob_below = norm.cdf(z_lower)
+        prob_between = 1 - prob_above - prob_below
+
+        annotations.append(dict(x=day, y=up_target + 0.5, text=f'P(> {round(up_target, 2)}): {prob_above*100:.2f}%', showarrow=False, textangle=45))
+        annotations.append(dict(x=day, y=down_target - 0.5, text=f'P(< {round(down_target, 2)}): {prob_below*100:.2f}%', showarrow=False, textangle=45))
+        annotations.append(dict(x=day, y=stock_price, text=f'P({round(down_target, 2)} to {round(up_target, 2)}): {prob_between*100:.2f}%', showarrow=False, textangle=45))
+        annotations.append(dict(x=day, y=lower_bound, text=f'{lower_bound:.2f}', showarrow=False, textangle=45))
+        annotations.append(dict(x=day, y=upper_bound, text=f'{upper_bound:.2f}', showarrow=False, textangle=45))
+
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=days, y=upper_bounds, mode='lines', line=dict(color='green', dash='dash'), name='Upper bound'))
+    fig.add_trace(go.Scatter(x=days, y=lower_bounds, mode='lines', line=dict(color='red', dash='dash'), name='Lower bound', fill='tonexty', fillcolor='rgba(135, 206, 235, 0.4)'))
+    fig.add_trace(go.Scatter(x=[days[0], days[-1]], y=[stock_price, stock_price], mode='lines', line=dict(color='blue', dash='solid'), name='Current price'))
+    fig.add_trace(go.Scatter(x=[days[0], days[-1]], y=[up_target, up_target], mode='lines', line=dict(color='purple', dash='dash'), name=f'Up target: {round(up_target, 2)}'))
+    fig.add_trace(go.Scatter(x=[days[0], days[-1]], y=[down_target, down_target], mode='lines', line=dict(color='orange', dash='dash'), name=f'Down target: {round(down_target, 2)}'))
+    fig.update_layout(title=f"Implied Volatility ({implied_volatility * 100:.2f}%) - Expected price range for {ticker}", xaxis_title='Days to options expiration', yaxis_title='Price', template='plotly_white', height=600, width=1200, showlegend=True, annotations=annotations)
+    return fig
+
+def monte_carlo_simulation(ticker, annual_iv, days_to_earnings, upper_target, lower_target, stock_data, num_simulations=10000):
+    current_price = stock_data['Close'].iloc[-1]
+    daily_iv = annual_iv / np.sqrt(252)
+    daily_returns = np.random.normal(0, daily_iv, (days_to_earnings, num_simulations))
+    price_paths = np.zeros_like(daily_returns)
+    price_paths[0] = current_price
+
+    for t in range(1, days_to_earnings):
+        price_paths[t] = price_paths[t-1] * (1 + daily_returns[t])
+
+    final_prices = price_paths[-1]
+    above_target = np.sum(final_prices > upper_target)
+    below_target = np.sum(final_prices < lower_target)
+    between_targets = num_simulations - above_target - below_target
+    prob_above = above_target / num_simulations
+    prob_below = below_target / num_simulations
+    prob_between = between_targets / num_simulations
+
+    fig = go.Figure()
+    for i in range(num_simulations):
+        fig.add_trace(go.Scatter(x=np.arange(days_to_earnings), y=price_paths[:, i], mode='lines', line=dict(color='lightblue', width=1), opacity=0.1, showlegend=False))
+
+    fig.add_trace(go.Scatter(x=[0, days_to_earnings-1], y=[upper_target, upper_target], mode='lines', line=dict(color='red', dash='dash'), name=f'Upper Target: {round(upper_target, 2)}'))
+    fig.add_trace(go.Scatter(x=[0, days_to_earnings-1], y=[lower_target, lower_target], mode='lines', line=dict(color='green', dash='dash'), name=f'Lower Target: {round(lower_target, 2)}'))
+    fig.add_trace(go.Scatter(x=[0, 0], y=[price_paths.min(), price_paths.max()], mode='lines', line=dict(color='red', dash='dash'), showlegend=False))
+
+    fig.add_annotation(x=0.05, y=0.95, xref='paper', yref='paper', text=f'P(>{round(upper_target, 2)}): {prob_above:.2%}<br>P(<{round(lower_target, 2)}): {prob_below:.2%}<br>P({round(lower_target, 2)}-{round(upper_target, 2)}): {prob_between:.2%}', showarrow=False, font=dict(size=12), bordercolor='black', borderwidth=1, bgcolor='wheat')
+    fig.update_layout(title=f"Monte Carlo Simulation of {ticker}'s Stock Price Over {days_to_earnings} Days", xaxis_title='Days', yaxis_title='Stock Price', template='plotly_white', height=600, width=1200, showlegend=True)
+    return fig
+
+import numpy as np
+import plotly.graph_objects as go
+
+def monte_carlo_normalized_prices(all_normalized_prices, upper_threshold, lower_threshold, latest_close_price, window_days, ticker):
+    # Flatten all normalized prices
+    all_prices_flattened = [price for sublist in all_normalized_prices for price in sublist if not np.isnan(price)]
+    
+    if len(all_prices_flattened) == 0:
+        return None
+
+    # Calculate log returns
+    log_returns = np.diff(np.log(all_prices_flattened))
+    
+    if len(log_returns) == 0:
+        return None
+
+    # Calculate drift and volatility for Monte Carlo
+    drift = np.mean(log_returns)
+    volatility = np.std(log_returns)
+    
+    if np.isnan(drift) or np.isnan(volatility):
+        return None
+
+    # Monte Carlo Simulation
+    np.random.seed(42)
+    t_intervals = len(window_days)
+    iterations = 10000
+
+    daily_returns = np.exp(drift + volatility * np.random.normal(0, 1, (t_intervals, iterations)))
+    price_paths = np.zeros_like(daily_returns)
+    price_paths[0, :] = 1  # Correct initialization of the starting point
+
+    for t in range(1, t_intervals):
+        price_paths[t, :] = price_paths[t - 1, :] * daily_returns[t, :]
+    
+    # Calculate the probabilities based on the Monte Carlo results
+    above_threshold = np.any(price_paths > upper_threshold, axis=0).sum()
+    below_threshold = np.any(price_paths < lower_threshold, axis=0).sum()
+    between_threshold = iterations - above_threshold - below_threshold
+
+    prob_above = above_threshold / iterations
+    prob_below = below_threshold / iterations
+    prob_between = between_threshold / iterations
+
+    # Plotting
+    fig = go.Figure()
+
+    # Plot Monte Carlo simulated paths
+    for i in range(iterations):
+        fig.add_trace(go.Scatter(
+            x=window_days,
+            y=price_paths[:, i],
+            mode='lines',
+            line=dict(color='gray', width=0.5),
+            opacity=0.1,
+            showlegend=False
+        ))
+
+    # Add horizontal lines for the percentage thresholds
+    fig.add_trace(go.Scatter(
+        x=[window_days[0], window_days[-1]],
+        y=[upper_threshold, upper_threshold],
+        mode='lines',
+        line=dict(color='green', dash='dash'),
+        showlegend=False
+    ))
+
+    fig.add_trace(go.Scatter(
+        x=[window_days[0], window_days[-1]],
+        y=[lower_threshold, lower_threshold],
+        mode='lines',
+        line=dict(color='orange', dash='dash'),
+        showlegend=False
+    ))
+
+    # Add the vertical line for earnings date
+    fig.add_trace(go.Scatter(
+        x=[0, 0],
+        y=[price_paths.min(), price_paths.max()],
+        mode='lines',
+        line=dict(color='red', dash='dash'),
+        showlegend=False
+    ))
+
+    # Update layout
+    fig.update_layout(
+        title=f"Monte Carlo Simulation of Price Movements for {ticker}",
+        xaxis_title="Days Relative to Earnings Date",
+        yaxis_title="Simulated Normalized Price",
+        template="plotly_white",
+        height=600,
+        width=1200
+    )
+
+    # Add secondary y-axis for actual stock prices
+    fig.update_layout(
+        yaxis2=dict(
+            title="Stock Price",
+            overlaying="y",
+            side="right",
+            range=[price_paths.min() * latest_close_price, price_paths.max() * latest_close_price]
+        )
+    )
+
+    # Annotate the plot with the probabilities
+    fig.add_annotation(
+        x=0.98,
+        y=0.98,
+        xref="paper",
+        yref="paper",
+        text=f"Prob. Above +{(upper_threshold-1)*100:.2f}%: {prob_above:.2%}<br>"
+             f"Actual Price: {round(latest_close_price * upper_threshold, 2)}",
+        showarrow=False,
+        align="right",
+        bordercolor="black",
+        borderwidth=1,
+        bgcolor="white"
+    )
+
+    fig.add_annotation(
+        x=0.98,
+        y=0.90,
+        xref="paper",
+        yref="paper",
+        text=f"Prob. Below -{(1-lower_threshold)*100:.2f}%: {prob_below:.2%}<br>"
+             f"Actual Price: {round(latest_close_price * lower_threshold, 2)}",
+        showarrow=False,
+        align="right",
+        bordercolor="black",
+        borderwidth=1,
+        bgcolor="white"
+    )
+
+    fig.add_annotation(
+        x=0.98,
+        y=0.82,
+        xref="paper",
+        yref="paper",
+        text=f"Prob. Between: {prob_between:.2%}",
+        showarrow=False,
+        align="right",
+        bordercolor="black",
+        borderwidth=1,
+        bgcolor="white"
+    )
+
+    return fig
+
+# Streamlit app
+st.set_page_config(layout="wide")
+st.title("Earnings Announcements Analysis")
+st.write(
+    """
+    This tool helps you analyze the impact of earnings announcements 
+    on a company's stock price. By providing a ticker symbol and configuring the analysis parameters in the sidebar, 
+    you can explore various aspects of stock price behavior around earnings dates and the likelihood of future movements.
+    
+    Key features include:
+    
+    - **Stock Price with Earnings Surprises**: Visualize the stock price movement with indicators for positive and negative earnings surprises.
+    - **Normalized Price Movements**: Examine how the stock price changes relative to its price on the earnings announcement date.
+    - **Volatility Analysis**: Assess the stock's volatility around earnings dates to understand the market's reaction.
+    - **Volume Trends**: Analyze the trading volume before and after earnings announcements.
+    - **Price Effects**: Compare stock prices before, during, and after earnings to quantify the impact.
+    - **Earnings Surprise vs. Price Effect**: Investigate the correlation between earnings surprises and subsequent price changes.
+    - **Monte Carlo Simulations**: Use advanced statistical techniques to predict future price movements and estimate the probabilities of reaching specific price targets.
+    
+    To get started, enter the ticker symbol of the stock you want to analyze and adjust the parameters in the sidebar. 
+    Once you're ready, click "Run Analysis" to generate the visualizations and insights.
+    """
+)
+
+# Sidebar inputs
+#st.sidebar.header("Configuration")
+
+st.sidebar.markdown("## How to Use")
+st.sidebar.write("""
+1. Enter the ticker symbol for the stock you want to analyze.
+2. Adjust the pre and post-announcement windows to define the period around earnings dates.
+3. Set the threshold percentage for price movement analysis.
+4. Configure buffer days for fetching stock data.
+5. Enter the implied volatility and days until earnings for Monte Carlo simulation.
+6. Set the number of simulations for more precise results.
+7. Click the "Run Analysis" button to start the analysis.
+""")
+
+st.sidebar.header("Input Parameters")
+
+ticker = st.sidebar.text_input("Enter Ticker Symbol", "ASML")
+pre_announcement_window = st.sidebar.number_input("Pre-announcement Window (days)", value=5, min_value=1)
+post_announcement_window = st.sidebar.number_input("Post-announcement Window (days)", value=10, min_value=1)
+threshold_percentage = st.sidebar.number_input("Threshold Percentage", value=0.10, min_value=0.01, max_value=1.0, step=0.01)
+buffer_days = st.sidebar.number_input("Buffer Days", value=10, min_value=1)
+implied_volatility = st.sidebar.number_input("Implied Volatility", value=0.30, min_value=0.01, max_value=1.0, step=0.01)
+days_until_earnings = st.sidebar.number_input("Days Until Earnings", value=10, min_value=1)
+num_simulations = st.sidebar.number_input("Number of Simulations for Monte Carlo", value=10000, min_value=100)
+
+
+
+if st.sidebar.button("Run Analysis"):
+    # Fetch data
+    earnings_dates = fetch_earnings_data(ticker)
+    current_time = pd.Timestamp.now().tz_localize(None)
+    future_eps_estimate = earnings_dates.loc[earnings_dates.index > current_time]
+    if not future_eps_estimate.empty:
+        future_eps_estimate = future_eps_estimate.iloc[0]['EPS Estimate']
+    else:
+        future_eps_estimate = None
+    stock_data = fetch_stock_data(ticker, earnings_dates.index.min(), earnings_dates.index.max(), buffer_days)
+    stock_data = calculate_metrics(stock_data)
+
+    latest_close_price = stock_data['Close'].iloc[-1]
+    upper_threshold = 1 + threshold_percentage
+    lower_threshold = 1 - threshold_percentage
+
+    # Normalize price movements around earnings dates
+    all_normalized_prices = []
+    for earning_date in earnings_dates.index:
+        start = earning_date - pd.Timedelta(days=pre_announcement_window)
+        end = earning_date + pd.Timedelta(days=post_announcement_window)
+        subset = stock_data.loc[start:end]['Close'].copy()
+        subset = ensure_window_size(subset, earning_date, pre_announcement_window, post_announcement_window)
+        subset.ffill(inplace=True)
+        subset.bfill(inplace=True)
+        subset = subset / subset[0]
+        all_normalized_prices.append(subset.tolist())
+
+    # Display earnings data before processing
+    st.subheader("Earnings Announcements Data")
+    st.dataframe(earnings_dates)
+
+    # Plot and display charts
+    st.subheader("Stock Price with Earnings Surprises")
+    st.markdown("This chart shows the stock price movements with markers indicating earnings surprises. "
+                "Positive earnings surprises are marked with green upward triangles, while negative surprises "
+                "are marked with red downward triangles. The size of the marker indicates the magnitude of the surprise.")
+    st.plotly_chart(plot_stock_price_with_earnings(stock_data, earnings_dates, ticker), use_container_width=True)
+
+    st.subheader("Normalized Price Movements Around Earnings Dates")
+    st.markdown("This plot shows the normalized price movements of the stock around earnings dates. "
+                "The prices are normalized to the price on the earnings date (Day 0). "
+                "We analyze the price behavior before and after the earnings announcement within a specified window. "
+                "The plot also calculates the probabilities of price movements exceeding given thresholds.")
+    st.latex(r"""
+        \text{Normalized Price} = \frac{\text{Stock Price}}{\text{Stock Price on Day 0}}
+    """)
+    st.markdown("To calculate the probabilities, we count the number of times the normalized prices exceed the upper threshold "
+                "or fall below the lower threshold. These counts are then divided by the total number of observations to get the probabilities.")
+    st.latex(r"""
+        \text{Probability Above} = \frac{\text{Count of Prices Above Upper Threshold}}{\text{Total Observations}}
+    """)
+    st.latex(r"""
+        \text{Probability Below} = \frac{\text{Count of Prices Below Lower Threshold}}{\text{Total Observations}}
+    """)
+    st.latex(r"""
+        \text{Probability Between} = 1 - \text{Probability Above} - \text{Probability Below}
+    """)
+    st.plotly_chart(plot_normalized_price_movements(stock_data, earnings_dates, ticker, pre_announcement_window, post_announcement_window, upper_threshold, lower_threshold), use_container_width=True)
+
+    st.subheader("Volatility Around Earnings Dates")
+    st.markdown("This plot shows the 20-day rolling volatility of the stock price around earnings dates. "
+                "Volatility is calculated as the standard deviation of daily returns over a 20-day window.")
+    st.latex(r"""
+        \sigma_{20D} = \sqrt{\frac{1}{19} \sum_{i=1}^{20} (R_i - \bar{R})^2}
+    """)
+    st.plotly_chart(plot_volatility_around_earnings(stock_data, earnings_dates), use_container_width=True)
+
+    st.subheader("Volume Around Earnings Dates")
+    st.markdown("This plot shows the trading volume changes around earnings dates. "
+                "We analyze the volume trends within a specified window around the earnings announcements.")
+    st.plotly_chart(plot_volume_around_earnings(stock_data, earnings_dates), use_container_width=True)
+
+    price_effects = earnings_dates.index.to_series().apply(compute_price_effect, stock_data=stock_data)
+    earnings_dates[['Price Before', 'Price On', 'Price After', 'Price Effect (%)']] = pd.DataFrame(price_effects.tolist(), index=earnings_dates.index)
+    earnings_dates.dropna(subset=['Price Before', 'Price On', 'Price After'], inplace=True)
+
+    st.subheader("Price Effects Around Earnings Dates")
+    st.markdown("This bar chart compares the stock prices before, on, and after the earnings dates. "
+                "It also shows the percentage change in price as the 'Price Effect' due to the earnings announcement.")
+    st.plotly_chart(plot_price_effects(earnings_dates), use_container_width=True)
+
+    st.subheader("Earnings Surprise vs. Price Effect")
+    st.markdown("This scatter plot shows the relationship between earnings surprise percentages and the resulting price effects. "
+                "A regression line is fitted to show the correlation between these two variables.")
+    st.latex(r"""
+        \text{Price Effect (\%)} = \beta_0 + \beta_1 \times \text{Surprise (\%)}
+    """)
+    st.plotly_chart(plot_surprise_vs_price_effect(earnings_dates), use_container_width=True)
+
+    st.subheader("Monte Carlo Simulation for Normalized Price Movements")
+    st.markdown("This plot shows the results of a Monte Carlo simulation for normalized price movements around earnings dates. "
+                "We simulate multiple price paths to estimate the probabilities of price movements exceeding given thresholds.")
+    window_days = list(range(-pre_announcement_window, post_announcement_window + 1))
+    st.plotly_chart(monte_carlo_normalized_prices(all_normalized_prices, upper_threshold, lower_threshold, latest_close_price, window_days, ticker), use_container_width=True)
+
+    up_target = latest_close_price * upper_threshold
+    down_target = latest_close_price * lower_threshold
+
+    st.subheader("Expected Price Range Based on Implied Volatility")
+    st.markdown("This plot shows the expected price range of the stock based on implied volatility over a specified period. "
+                "It uses the current stock price and implied volatility to estimate the upper and lower bounds.")
+    st.latex(r"""
+        \text{Upper Bound} = S_0 \times (1 + \sigma \sqrt{t})
+    """)
+    st.latex(r"""
+        \text{Lower Bound} = S_0 \times (1 - \sigma \sqrt{t})
+    """)
+    st.plotly_chart(plot_price_ranges(ticker, implied_volatility, days_until_earnings, up_target, down_target, stock_data), use_container_width=True)
+
+    st.subheader("Monte Carlo Simulation for Price Movements")
+    st.markdown("We simulate multiple price paths using the stock's implied volatility to estimate the probabilities of the stock price reaching given targets.")
+    st.markdown("Implied volatility (IV) is used to model the expected volatility of the stock's price. "
+                "The simulation generates random price paths based on the IV, the current stock price, and the time remaining until the earnings date.")
+    st.plotly_chart(monte_carlo_simulation(ticker, implied_volatility, days_until_earnings, up_target, down_target, stock_data, num_simulations), use_container_width=True)
+