app.py

import yfinance as yf
import numpy as np
import pandas as pd
import streamlit as st
import plotly.graph_objects as go

# Fetch stock data
def get_stock_data(ticker, start_date, end_date):
    stock_data = yf.download(ticker, start=start_date, end=end_date)
    return stock_data['Close']

# Bootstrapping simulation function
def bootstrap_simulation(data, days, n_iterations=10000):
    daily_returns = data.pct_change().dropna()
    simulations = np.zeros((n_iterations, days))

    for i in range(n_iterations):
        sample = np.random.choice(daily_returns, size=days, replace=True)
        simulations[i] = np.cumprod(1 + sample) * data.iloc[-1]

    return simulations

# Calculate probabilities
def calculate_probabilities(simulations, thresholds):
    final_prices = simulations[:, -1]
    below = np.mean(final_prices < thresholds[0])
    above = np.mean(final_prices > thresholds[1])
    between = np.mean((final_prices >= thresholds[0]) & (final_prices <= thresholds[1]))

    return {'below': below, 'between': between, 'above': above}

# Calculate percentiles
def calculate_percentiles(simulations):
    percentiles = np.percentile(simulations, [2.5, 16, 50, 84, 97.5], axis=0)
    return percentiles

# Plot distributions
def plot_distributions(bootstrap_simulations, data, thresholds, bootstrap_probabilities):
    final_bootstrap_prices = bootstrap_simulations[:, -1]

    mean_bootstrap_price = np.mean(final_bootstrap_prices)
    median_bootstrap_price = np.median(final_bootstrap_prices)
    ci_68_bootstrap = np.percentile(final_bootstrap_prices, [16, 84])
    ci_95_bootstrap = np.percentile(final_bootstrap_prices, [2.5, 97.5])
    latest_price = data.iloc[-1]

    fig = go.Figure()

    # Plot for Bootstrapping
    fig.add_trace(go.Histogram(x=final_bootstrap_prices, nbinsx=50, name='Simulated Final Prices',
                               marker_color='blue', opacity=0.7))
    fig.add_vline(x=mean_bootstrap_price, line=dict(color='red', dash='dash'), name=f'Mean: {mean_bootstrap_price:.2f}')
    fig.add_vline(x=median_bootstrap_price, line=dict(color='orange', dash='dash'), name=f'Median: {median_bootstrap_price:.2f}')
    fig.add_vline(x=latest_price, line=dict(color='green', dash='dash'), name=f'Latest Price: {latest_price:.2f}')
    fig.add_vrect(x0=ci_68_bootstrap[0], x1=ci_68_bootstrap[1], fillcolor='yellow', opacity=0.2, layer="below", line_width=0, annotation_text="68% CI", annotation_position="top left")
    fig.add_vrect(x0=ci_95_bootstrap[0], x1=ci_95_bootstrap[1], fillcolor='grey', opacity=0.2, layer="below", line_width=0, annotation_text="95% CI", annotation_position="top left")
    
    max_freq = np.histogram(final_bootstrap_prices, bins=50)[0].max()

    # Calculate positions based on a fraction of the max frequency
    mean_y_pos = max_freq * 0.9
    median_y_pos = max_freq * 0.7
    latest_y_pos = max_freq * 0.5

    # Annotations for the vertical lines
    fig.add_annotation(x=mean_bootstrap_price, y=mean_y_pos, text=f'Mean: {mean_bootstrap_price:.2f}', showarrow=False)
    fig.add_annotation(x=median_bootstrap_price, y=median_y_pos, text=f'Median: {median_bootstrap_price:.2f}', showarrow=False)
    fig.add_annotation(x=latest_price, y=latest_y_pos, text=f'Latest: {latest_price:.2f}', showarrow=False)

    textstr = f'P(>{thresholds[1]:.2f}): {bootstrap_probabilities["above"]:.2%}<br>' + \
              f'P(<{thresholds[0]:.2f}): {bootstrap_probabilities["below"]:.2%}<br>' + \
              f'P({thresholds[0]:.2f} - {thresholds[1]:.2f}): {bootstrap_probabilities["between"]:.2%}'
    fig.add_annotation(xref='paper', yref='paper', x=0.98, y=0.02, text=textstr, showarrow=False, 
                       bordercolor="black", borderwidth=1, borderpad=4, bgcolor="white", opacity=0.8)

    fig.update_layout(title='Bootstrapping Simulation', xaxis_title='Final Price', yaxis_title='Frequency', showlegend=True)
    return fig, mean_bootstrap_price, median_bootstrap_price, ci_68_bootstrap, ci_95_bootstrap, latest_price

# Plot price data with simulation cones
def plot_price_with_cones(data, bootstrap_percentiles, days, thresholds, bootstrap_probabilities):
    last_date = data.index[-1]
    future_dates = pd.date_range(start=last_date + pd.Timedelta(days=1), periods=days, freq='D')

    fig = go.Figure()

    # Plot historical prices
    fig.add_trace(go.Scatter(x=data.index, y=data, mode='lines', name='Historical Prices', line=dict(color='black')))

    # Plot bootstrapping simulation cone
    fig.add_trace(go.Scatter(x=future_dates, y=bootstrap_percentiles[2], mode='lines', name='Bootstrap Median', line=dict(color='red', dash='dash')))
    fig.add_trace(go.Scatter(x=future_dates, y=bootstrap_percentiles[0], fill=None, mode='lines', line=dict(color='lightgrey'), showlegend=False))
    fig.add_trace(go.Scatter(x=future_dates, y=bootstrap_percentiles[4], fill='tonexty', mode='lines', line=dict(color='lightgrey'), name='Bootstrap 95% CI'))
    fig.add_trace(go.Scatter(x=future_dates, y=bootstrap_percentiles[1], fill=None, mode='lines', line=dict(color='lightyellow'), showlegend=False))
    fig.add_trace(go.Scatter(x=future_dates, y=bootstrap_percentiles[3], fill='tonexty', mode='lines', line=dict(color='lightyellow'), name='Bootstrap 68% CI'))

    # Annotate the thresholds
    fig.add_hline(y=thresholds[0], line=dict(color='blue', dash='dash'), annotation_text=f'Threshold 1: {thresholds[0]}', annotation_position="top left")
    fig.add_hline(y=thresholds[1], line=dict(color='green', dash='dash'), annotation_text=f'Threshold 2: {thresholds[1]}', annotation_position="top left")

    # Add probability annotations
    textstr_bootstrap = f'Bootstrap Probabilities:<br>Below {thresholds[0]}: {bootstrap_probabilities["below"]:.2%}<br>' + \
                        f'Between {thresholds[0]} and {thresholds[1]}: {bootstrap_probabilities["between"]:.2%}<br>' + \
                        f'Above {thresholds[1]}: {bootstrap_probabilities["above"]:.2%}'
    fig.add_annotation(xref='paper', yref='paper', x=0.98, y=0.02, text=textstr_bootstrap, showarrow=False, 
                       bordercolor="black", borderwidth=1, borderpad=4, bgcolor="white", opacity=0.8)

    fig.update_layout(title='Bootstrapping Simulation Cone', xaxis_title='Date', yaxis_title='Price', showlegend=True)
    fig.update_xaxes(type='date')
    
    return fig

# Streamlit app
st.title('Stock Price Simulation')

st.sidebar.header('Input Parameters')

st.write("""
### Description
This application simulates future stock prices using bootstrapping simulation methods.
You can specify the stock ticker, the date range, the number of simulation days, the number of simulations, and price thresholds.
The simulation results will show the probability of the stock price falling below, between, or above the specified thresholds.

**How to use:**
1. Enter the stock ticker, start date, and end date.
2. Set the number of days for the simulation and the number of iterations.
3. Enter the price thresholds.
4. Click 'Run Simulation' to start the bootstrapping simulation.

**Results:**
The app will display two charts:
1. The distribution of the final simulated prices with key statistical measures.
2. The historical stock prices with simulated future price cones and the specified thresholds.
""")

ticker = st.sidebar.text_input('Enter Stock Ticker', 'ASML.AS')
start_date = st.sidebar.date_input('Start Date', pd.to_datetime('2020-01-01'))
end_date = st.sidebar.date_input('End Date', pd.to_datetime('2025-01-01'))
days = st.sidebar.number_input('Number of Days for Simulation', min_value=1, max_value=365, value=30)
n_iterations = st.sidebar.number_input('Number of Simulations', min_value=100, max_value=100000, value=10000)
threshold1 = st.sidebar.number_input('Threshold 1', min_value=0, value=850)
threshold2 = st.sidebar.number_input('Threshold 2', min_value=0, value=1000)
thresholds = [threshold1, threshold2]

if st.sidebar.button('Run Simulation'):
    data = get_stock_data(ticker, start_date, end_date)

    bootstrap_simulations = bootstrap_simulation(data, days, n_iterations)

    bootstrap_probabilities = calculate_probabilities(bootstrap_simulations, thresholds)

    bootstrap_percentiles = calculate_percentiles(bootstrap_simulations)

    fig1, mean_bootstrap_price, median_bootstrap_price, ci_68_bootstrap, ci_95_bootstrap, latest_price = plot_distributions(bootstrap_simulations, data, thresholds, bootstrap_probabilities)
    fig2 = plot_price_with_cones(data, bootstrap_percentiles, days, thresholds, bootstrap_probabilities)

    st.plotly_chart(fig1)
    st.plotly_chart(fig2)

    st.write(f"""
    ### Interpretation of Results

    **Distribution of Final Simulated Prices:**
    - **Mean Final Price:** {mean_bootstrap_price:.2f}
    - **Median Final Price:** {median_bootstrap_price:.2f}
    - **68% Confidence Interval (CI):** [{ci_68_bootstrap[0]:.2f}, {ci_68_bootstrap[1]:.2f}]
    - **95% Confidence Interval (CI):** [{ci_95_bootstrap[0]:.2f}, {ci_95_bootstrap[1]:.2f}]
    - **Latest Price:** {latest_price:.2f}

    **Bootstrapping Simulation Cone:**
    - **Bootstrap Median:** The median of the simulated future prices for each day.
    - **Bootstrap 68% CI:** The 68% confidence interval for the simulated future prices.
    - **Bootstrap 95% CI:** The 95% confidence interval for the simulated future prices.
    - **Threshold 1 and Threshold 2:** {threshold1:.2f}, {threshold2:.2f}
    - **Probability Annotations:**
      - The probability of the stock price being below Threshold 1: {bootstrap_probabilities["below"]:.2%}
      - The probability of the stock price being between Threshold 1 and Threshold 2: {bootstrap_probabilities["between"]:.2%}
      - The probability of the stock price being above Threshold 2: {bootstrap_probabilities["above"]:.2%}
    """)