Create app.py

app.py

@@ -0,0 +1,256 @@
+import streamlit as st
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import plotly.graph_objs as go
+from itertools import product
+from datetime import datetime, timedelta
+from plotly.subplots import make_subplots
+
+# Set Streamlit page configuration
+st.set_page_config(page_title="3-Way Moving Average Crossover Strategy", layout="wide")
+
+# Title and description
+st.title("3-Way Moving Average Crossover Strategy")
+st.write("""
+This tool allows users to backtest a 3-way moving average crossover strategy across different time horizons (short-term, medium-term, and long-term).
+The strategy uses three different moving averages to generate buy/sell signals when shorter-term averages cross above or below longer-term averages.
+By adjusting parameters like the length of each moving average and the signal threshold, you can further customize how strict or lenient the crossover signals are.
+""")
+
+# Sidebar: How to use the app
+with st.sidebar.expander("How to Use", expanded=False):
+    st.write("""
+    1. **Select Ticker**: Choose the asset ticker symbol (e.g., AAPL, TSLA, BTC-USD) and date range for historical data.
+    2. **Run Strategy**: Click "Run Strategy" to perform optimization and backtesting of the strategy using the default parameters for the selected horizon.
+    3. **Adjust Parameters**: After running the strategy, use the sliders to adjust the moving average windows and threshold, and see the results update live.
+    4. **Threshold Parameter**: Controls how strict the buy/sell signals are when moving averages cross. Lower thresholds generate more signals; higher thresholds generate fewer, stricter signals.
+    """)
+
+# Sidebar: Navigation
+st.sidebar.markdown("### Page Navigation")
+page = st.sidebar.radio("Select Strategy Horizon", options=["Short-Term", "Medium-Term", "Long-Term"])
+
+# Sidebar: Select Ticker and Date Range
+with st.sidebar.expander("Select Ticker and Date Range", expanded=True):
+    ticker = st.text_input("Asset Symbol", value="AAPL", help="Ticker symbol (Indicate the stock ticker or Cryptocurrency Pair (e.g., AAPL, BTC-USD))")
+    start_date = st.date_input("Start Date", value=datetime(2015, 1, 1), help="Select the start date for historical data.")
+    end_date = st.date_input("End Date", value=datetime.today() + timedelta(days=1), help="Select the end date for historical data.")
+
+# Function to download data
+@st.cache_data
+def download_data(ticker, start, end):
+    data = yf.download(ticker, start=start, end=end)
+    return data
+
+# Function to calculate moving averages
+def calculate_moving_averages(data, short_window, medium_window, long_window):
+    data['short_ma'] = data['Adj Close'].rolling(window=short_window).mean()
+    data['medium_ma'] = data['Adj Close'].rolling(window=medium_window).mean()
+    data['long_ma'] = data['Adj Close'].rolling(window=long_window).mean()
+    return data
+
+# Function to generate trading signals with a percentage-based threshold
+def generate_signals(data, threshold=0.01):
+    data['signal'] = 0
+    data['signal'][(data['short_ma'] > data['medium_ma'] * (1 + threshold)) & 
+                   (data['medium_ma'] > data['long_ma'] * (1 + threshold))] = 1
+    data['signal'][(data['short_ma'] < data['medium_ma'] * (1 - threshold)) & 
+                   (data['medium_ma'] < data['long_ma'] * (1 - threshold))] = -1
+    data['positions'] = data['signal'].diff()
+    return data
+
+# Function to calculate equity curve
+def calculate_equity_curve(data):
+    data['returns'] = data['Adj Close'].pct_change()
+    data['strategy_returns'] = data['returns'] * data['signal'].shift(1)
+    data['equity_curve'] = (1 + data['strategy_returns']).cumprod()
+    return data
+
+# Function to optimize parameters for different trading terms
+def optimize_parameters(data, short_window_range, medium_window_range, long_window_range):
+    best_params = None
+    best_equity = 0
+
+    for short, medium, long in product(short_window_range, medium_window_range, long_window_range):
+        if short < medium < long:
+            df = calculate_moving_averages(data.copy(), short, medium, long)
+            df = generate_signals(df)
+            df = calculate_equity_curve(df)
+            final_equity = df['equity_curve'].iloc[-1]
+            if final_equity > best_equity:
+                best_equity = final_equity
+                best_params = (short, medium, long)
+
+    return best_params, best_equity
+
+# Function to execute and plot the strategy
+def execute_strategy(data, short_window, medium_window, long_window, threshold, title_suffix):
+    data = calculate_moving_averages(data, short_window, medium_window, long_window)
+    data = generate_signals(data, threshold)
+    data = calculate_equity_curve(data)
+    return data
+
+# Function to plot results
+# Function to plot results with subplots for better alignment
+def plot_results(data, params, title_suffix):
+    # Create subplots: 2 rows (Price + MA, and Equity Curve), shared x-axis for alignment
+    fig = make_subplots(
+        rows=2, cols=1, shared_xaxes=True,
+        vertical_spacing=0.1,  # Increased vertical spacing between plots
+        subplot_titles=(f'{title_suffix} Price and Moving Averages', 'Equity Curve')
+    )
+
+    # Price and Moving Averages plot
+    fig.add_trace(go.Scatter(x=data.index, y=data['Adj Close'], mode='lines', name='Price', line=dict(color='black')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=data.index, y=data['short_ma'], mode='lines', name=f'Short MA ({params[0]})', line=dict(color='blue')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=data.index, y=data['medium_ma'], mode='lines', name=f'Medium MA ({params[1]})', line=dict(color='orange')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=data.index, y=data['long_ma'], mode='lines', name=f'Long MA ({params[2]})', line=dict(color='green')), row=1, col=1)
+
+    # Buy/Sell Signals with markers
+    buy_signals = data[data['positions'] == 1]
+    sell_signals = data[data['positions'] == -1]
+    fig.add_trace(go.Scatter(x=buy_signals.index, y=buy_signals['short_ma'], mode='markers', name='Buy Signal',
+                             marker=dict(color='green', symbol='triangle-up', size=10)), row=1, col=1)
+    fig.add_trace(go.Scatter(x=sell_signals.index, y=sell_signals['short_ma'], mode='markers', name='Sell Signal',
+                             marker=dict(color='red', symbol='triangle-down', size=10)), row=1, col=1)
+
+    # Equity Curve plot
+    fig.add_trace(go.Scatter(x=data.index, y=data['equity_curve'], mode='lines', name='Equity Curve', line=dict(color='blue')), row=2, col=1)
+
+    # Update layout for better clarity and spacing
+    fig.update_layout(
+        height=800,  # Increased height for better visualization
+        title_text=f'{title_suffix} 3-Way Moving Average Crossover',
+        xaxis_title='Date',
+        yaxis_title='Price',
+        legend=dict(orientation="h", yanchor="bottom", y=1.05, xanchor="center", x=0.5),
+        margin=dict(t=30, b=30),  # Adjust top and bottom margins for spacing
+        font=dict(size=12),
+        showlegend=True
+    )
+
+    # Display the chart in Streamlit
+    st.plotly_chart(fig, use_container_width=True)
+
+# Load and cache data
+data = download_data(ticker, start_date, end_date)
+
+# Short, Medium, Long-Term settings
+horizons = {
+    "Short-Term": {"short_range": range(2, 10, 1), "medium_range": range(10, 20, 1), "long_range": range(20, 50, 2)},
+    "Medium-Term": {"short_range": range(10, 30, 2), "medium_range": range(30, 60, 3), "long_range": range(60, 100, 5)},
+    "Long-Term": {"short_range": range(30, 60, 5), "medium_range": range(60, 120, 10), "long_range": range(120, 200, 10)}
+}
+
+# Cache the results for each horizon so they persist when switching between pages
+if "results_cache" not in st.session_state:
+    st.session_state["results_cache"] = {}
+
+# Initialize or update the MA parameters and threshold based on the selected page
+if page in st.session_state["results_cache"]:
+    params = st.session_state["results_cache"][page]["params"]
+    threshold_value = st.session_state["results_cache"][page]["threshold"]
+else:
+    params = None
+    threshold_value = 0.01  # Default value for threshold
+
+# Run Strategy Button
+run_strategy = st.sidebar.button(f"Run Strategy for {page}")
+run_with_adjusted_params = False
+
+# If Run Strategy is clicked, run optimization and reset parameters
+if run_strategy:
+    horizon_settings = horizons.get(page)
+    
+    # Re-run optimization and reset to best parameters
+    best_params, best_equity = optimize_parameters(
+        data, 
+        short_window_range=horizon_settings["short_range"], 
+        medium_window_range=horizon_settings["medium_range"], 
+        long_window_range=horizon_settings["long_range"]
+    )
+    
+    # Cache the best parameters and reset adjusted parameters to best params
+    st.session_state["results_cache"][page] = {
+        "best_params": best_params,
+        "best_equity": best_equity,
+        "threshold": threshold_value,  # Store the default threshold initially
+        "params": best_params,         # Reset to best params after optimization
+    }
+
+    # Reset sliders to best parameters after optimization
+    params = best_params
+    run_with_adjusted_params = True
+
+# If user-adjusted parameters (after the initial run)
+if params:
+    horizon_settings = horizons.get(page)
+    
+    short_window = st.sidebar.slider(
+        f"Short MA Window ({page})", 
+        min_value=horizon_settings["short_range"].start, 
+        max_value=horizon_settings["short_range"].stop - 1, 
+        value=params[0], 
+        help="Defines the window for the shortest moving average. Increasing this value smooths the moving average and reduces its sensitivity to price changes."
+    )
+    
+    medium_window = st.sidebar.slider(
+        f"Medium MA Window ({page})", 
+        min_value=horizon_settings["medium_range"].start, 
+        max_value=horizon_settings["medium_range"].stop - 1, 
+        value=params[1], 
+        help="Defines the window for the medium moving average. A larger window increases smoothing and lags price changes more than the short MA."
+    )
+    
+    long_window = st.sidebar.slider(
+        f"Long MA Window ({page})", 
+        min_value=horizon_settings["long_range"].start, 
+        max_value=horizon_settings["long_range"].stop - 1, 
+        value=params[2], 
+        help="Defines the window for the long moving average. A larger window results in a much slower-moving average that tracks long-term trends."
+    )
+    
+    threshold = st.sidebar.slider(
+        f"Threshold ({page})", 
+        0.0, 0.05, threshold_value, 0.01, 
+        help="Adjusts the strictness of the crossover signals. A higher threshold generates fewer, stricter signals."
+    )
+
+    # If any adjustments are made to the parameters, mark the run as "adjusted"
+    run_with_adjusted_params = True
+    
+    # Execute the strategy using user-adjusted parameters
+    result_data = execute_strategy(data.copy(), short_window, medium_window, long_window, threshold, page)
+
+    # Cache updated parameters and threshold without overwriting the best params
+    st.session_state["results_cache"][page]["params"] = (short_window, medium_window, long_window)
+    st.session_state["results_cache"][page]["threshold"] = threshold
+    st.session_state["results_cache"][page]["data"] = result_data
+
+# If results are cached, display them
+if page in st.session_state["results_cache"]:
+    cached_result = st.session_state["results_cache"][page]
+
+    # Display best parameters in JSON (always show the optimized "best" params, not the adjusted ones)
+    st.json({
+        "Best Parameters": {
+            "Short MA": cached_result["best_params"][0],
+            "Medium MA": cached_result["best_params"][1],
+            "Long MA": cached_result["best_params"][2],
+            "Threshold": cached_result["threshold"],
+            "Final Equity": cached_result["best_equity"]
+        }
+    })
+
+    # Plot results with either optimized or adjusted parameters
+    if "data" in cached_result:
+        plot_results(cached_result["data"], cached_result["params"], page)
+
+hide_streamlit_style = """
+<style>
+#MainMenu {visibility: hidden;}
+footer {visibility: hidden;}
+</style>
+"""
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)