Update app.py

app.py

@@ -1,177 +1,1379 @@
+import streamlit as st
 import yfinance as yf
-import talib
 import pandas as pd
-import streamlit as st
-import plotly.graph_objects as go
+import plotly.graph_objs as go
+import numpy as np
+import talib
+from pandas import Series
+from numpy import average as npAverage, nan as npNaN, log as npLog, power as npPower, sqrt as npSqrt, zeros_like as npZeroslike
+from pandas_ta.utils import get_offset, verify_series
+from datetime import datetime
+from matplotlib.dates import date2num
 
-# Set page configuration
 st.set_page_config(layout="wide")
 
-# Define pattern functions
-pattern_funcs = [
-    ("Two Crows", talib.CDL2CROWS),
-    ("Three Black Crows", talib.CDL3BLACKCROWS),
-    ("Three Inside Up/Down", talib.CDL3INSIDE),
-    ("Three-Line Strike", talib.CDL3LINESTRIKE),
-    ("Three Outside Up/Down", talib.CDL3OUTSIDE),
-    ("Three Stars In The South", talib.CDL3STARSINSOUTH),
-    ("Three Advancing White Soldiers", talib.CDL3WHITESOLDIERS),
-    ("Abandoned Baby", talib.CDLABANDONEDBABY),
-    ("Advance Block", talib.CDLADVANCEBLOCK),
-    ("Belt-hold", talib.CDLBELTHOLD),
-    ("Breakaway", talib.CDLBREAKAWAY),
-    ("Closing Marubozu", talib.CDLCLOSINGMARUBOZU),
-    ("Concealing Baby Swallow", talib.CDLCONCEALBABYSWALL),
-    ("Counterattack", talib.CDLCOUNTERATTACK),
-    ("Dark Cloud Cover", talib.CDLDARKCLOUDCOVER),
-    ("Doji", talib.CDLDOJI),
-    ("Doji Star", talib.CDLDOJISTAR),
-    ("Dragonfly Doji", talib.CDLDRAGONFLYDOJI),
-    ("Engulfing Pattern", talib.CDLENGULFING),
-    ("Evening Doji Star", talib.CDLEVENINGDOJISTAR),
-    ("Evening Star", talib.CDLEVENINGSTAR),
-    ("Up/Down-gap side-by-side white lines", talib.CDLGAPSIDESIDEWHITE),
-    ("Gravestone Doji", talib.CDLGRAVESTONEDOJI),
-    ("Hammer", talib.CDLHAMMER),
-    ("Hanging Man", talib.CDLHANGINGMAN),
-    ("Harami Pattern", talib.CDLHARAMI),
-    ("Harami Cross Pattern", talib.CDLHARAMICROSS),
-    ("High-Wave Candle", talib.CDLHIGHWAVE),
-    ("Hikkake Pattern", talib.CDLHIKKAKE),
-    ("Modified Hikkake Pattern", talib.CDLHIKKAKEMOD),
-    ("Homing Pigeon", talib.CDLHOMINGPIGEON),
-    ("Identical Three Crows", talib.CDLIDENTICAL3CROWS),
-    ("In-Neck Pattern", talib.CDLINNECK),
-    ("Inverted Hammer", talib.CDLINVERTEDHAMMER),
-    ("Kicking", talib.CDLKICKING),
-    ("Kicking - bull/bear determined by the longer marubozu", talib.CDLKICKINGBYLENGTH),
-    ("Ladder Bottom", talib.CDLLADDERBOTTOM),
-    ("Long Legged Doji", talib.CDLLONGLEGGEDDOJI),
-    ("Long Line Candle", talib.CDLLONGLINE),
-    ("Marubozu", talib.CDLMARUBOZU),
-    ("Matching Low", talib.CDLMATCHINGLOW),
-    ("Mat Hold", talib.CDLMATHOLD),
-    ("Morning Doji Star", talib.CDLMORNINGDOJISTAR),
-    ("Morning Star", talib.CDLMORNINGSTAR),
-    ("On-Neck Pattern", talib.CDLONNECK),
-    ("Piercing Pattern", talib.CDLPIERCING),
-    ("Rickshaw Man", talib.CDLRICKSHAWMAN),
-    ("Rising/Falling Three Methods", talib.CDLRISEFALL3METHODS),
-    ("Separating Lines", talib.CDLSEPARATINGLINES),
-    ("Shooting Star", talib.CDLSHOOTINGSTAR),
-    ("Short Line Candle", talib.CDLSHORTLINE),
-    ("Spinning Top", talib.CDLSPINNINGTOP),
-    ("Stalled Pattern", talib.CDLSTALLEDPATTERN),
-    ("Stick Sandwich", talib.CDLSTICKSANDWICH),
-    ("Takuri (Dragonfly Doji with very long lower shadow)", talib.CDLTAKURI),
-    ("Tasuki Gap", talib.CDLTASUKIGAP),
-    ("Thrusting Pattern", talib.CDLTHRUSTING),
-    ("Tristar Pattern", talib.CDLTRISTAR),
-    ("Unique 3 River", talib.CDLUNIQUE3RIVER),
-    ("Upside Gap Two Crows", talib.CDLUPSIDEGAP2CROWS),
-    ("Upside/Downside Gap Three Methods", talib.CDLXSIDEGAP3METHODS)
-]
-
-# Streamlit app setup
-st.title('Automatic Candlestick Pattern Detection')
-
-st.write("""
-This tool automatically detects 60+ candlestick patterns in stock price data. 
-* You can input the stock ticker (e.g. 'AAPL') or crypto pair (e.g. 'BTC-USD'), start date, and end date in the sidebar menu to analyze.
-* The tool will fetch the historical data and highlight detected patterns on the charts.
-* The charts display the stock price data along with vertical lines indicating where patterns were found.
-* If no patterns are detected, the chart for that pattern will not be included.
+
+st.title("Comprehensive Moving Averages Analysis Tool")
+
+st.markdown("""
+This app provides a detailed analysis of various moving averages. You can select from a wide range of techniques to better understand stock price movement trends.
+
+### Moving Averages Categories:
+
+- **Fundamental Techniques**: Includes **SMA**, **EMA**, **WMA**, **DEMA**, **TEMA**, **VAMA**, **KAMA**, **TMA**, and **HMA**.
+
+- **Adaptive and Dynamic Approaches**: Covers methods like **FRAMA**, **ZLEMA**, **VIDYA**, **ALMA**, **MAMA**, **Adaptive Period MA**, **Rainbow MA**, **Wilders MA**, and **SMMA**.
+
+- **Advanced Weighting Techniques**: Features **GMMA**, **LSMA**, **Welch’s MMA**, **Sin-weighted MA**, **Median MA**, **Geometric MA**, **eVWMA**, **REMA**, and **Parabolic WMA**.
+
+- **Specialized Methods**: Includes **JMA**, **EPMA**, **CMA**, **Harmonic MA**, **McGinley Dynamic**, **Anchored MA**, and **Filtered MA**.
+
+
+For technical details on these methods, refer to [this article](https://entreprenerdly.com/top-36-moving-averages-methods-for-stock-prices-in-python/).
+""")
+
+st.sidebar.markdown("""
+### How to Use:
+- **Ticker Symbol**: Enter the stock symbol (e.g., `AAPL`).
+- **Date Range**: Select the start and end dates.
+- **Fetch Data**: Click 'Fetch Data' to load the stock data.
+- **Moving Averages**: Choose and customize your moving averages.
+- **Run Analysis**: Click 'Run' to apply and visualize.
 """)
 
 
-st.sidebar.header('Input Parameters')
-symbol = st.sidebar.text_input('Enter Asset Symbol', 'AAPL')
-start_date = st.sidebar.date_input('Start Date', pd.to_datetime('2023-06-01'))
-end_date = st.sidebar.date_input('End Date', pd.to_datetime('2025-01-01'))
+# Function to fetch data
+@st.cache_data
+def get_data(ticker, start_date, end_date):
+    data = yf.download(ticker, start=start_date, end=end_date)
+    return data
+
+# Function to create the base plot with the stock price
+def create_price_plot(data, ticker_symbol):
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name=f'{ticker_symbol} Stock Price'))
+    return fig
+
+# Jurik Moving Average (JMA) Function
+def jma(close, length=None, phase=None, offset=None, **kwargs):
+    _length = int(length) if length and length > 0 else 7
+    phase = float(phase) if phase and phase != 0 else 0
+    close = verify_series(close, _length)
+    offset = get_offset(offset)
+    if close is None: return
+
+    jma = npZeroslike(close)
+    volty = npZeroslike(close)
+    v_sum = npZeroslike(close)
+
+    kv = det0 = det1 = ma2 = 0.0
+    jma[0] = ma1 = uBand = lBand = close[0]
+
+    sum_length = 10
+    length = 0.5 * (_length - 1)
+    pr = 0.5 if phase < -100 else 2.5 if phase > 100 else 1.5 + phase * 0.01
+    length1 = max((npLog(npSqrt(length)) / npLog(2.0)) + 2.0, 0)
+    pow1 = max(length1 - 2.0, 0.5)
+    length2 = length1 * npSqrt(length)
+    bet = length2 / (length2 + 1)
+    beta = 0.45 * (_length - 1) / (0.45 * (_length - 1) + 2.0)
+
+    m = close.shape[0]
+    for i in range(1, m):
+        price = close[i]
+
+        del1 = price - uBand
+        del2 = price - lBand
+        volty[i] = max(abs(del1), abs(del2)) if abs(del1) != abs(del2) else 0
+
+        v_sum[i] = v_sum[i - 1] + (volty[i] - volty[max(i - sum_length, 0)]) / sum_length
+        avg_volty = npAverage(v_sum[max(i - 65, 0):i + 1])
+        d_volty = 0 if avg_volty == 0 else volty[i] / avg_volty
+        r_volty = max(1.0, min(npPower(length1, 1 / pow1), d_volty))
+
+        pow2 = npPower(r_volty, pow1)
+        kv = npPower(bet, npSqrt(pow2))
+        uBand = price if (del1 > 0) else price - (kv * del1)
+        lBand = price if (del2 < 0) else price - (kv * del2)
+
+        power = npPower(r_volty, pow1)
+        alpha = npPower(beta, power)
+
+        ma1 = ((1 - alpha) * price) + (alpha * ma1)
+
+        det0 = ((price - ma1) * (1 - beta)) + (beta * det0)
+        ma2 = ma1 + pr * det0
+
+        det1 = ((ma2 - jma[i - 1]) * (1 - alpha) * (1 - alpha)) + (alpha * alpha * det1)
+        jma[i] = jma[i - 1] + det1
+
+    jma[0:_length - 1] = npNaN
+    jma = Series(jma, index=close.index)
+
+    if offset != 0:
+        jma = jma.shift(offset)
+
+    if "fillna" in kwargs:
+        jma.fillna(kwargs["fillna"], inplace=True)
+    if "fill_method" in kwargs:
+        jma.fillna(method=kwargs["fill_method"], inplace=True)
+
+    jma.name = f"JMA_{_length}_{phase}"
+    jma.category = "overlap"
+
+    return jma
+
+# Function to calculate Harmonic Moving Average (HMA)
+def calculate_harmonic_moving_average(prices, period):
+    harmonic_ma = []
+    for i in range(len(prices)):
+        if i < period - 1:
+            harmonic_ma.append(np.nan)
+        else:
+            window = prices[i - period + 1: i + 1]
+            harmonic_mean = period / np.sum(1.0 / window)
+            harmonic_ma.append(harmonic_mean)
+    return harmonic_ma
+
+# End Point Moving Average (EPMA) Function
+def calculate_EPMA(prices, period):
+    epma_values = []
+
+    for i in range(period - 1, len(prices)):
+        x = np.arange(period)
+        y = prices[i-period+1:i+1]
+
+        slope, intercept = np.polyfit(x, y, 1)
+        epma = slope * (period - 1) + intercept
+
+        epma_values.append(epma)
+
+    return [None]*(period-1) + epma_values  # Pad with None for alignment
+
+# Chande Moving Average (CMA) Function
+def calculate_CMA(prices):
+    cumsum = np.cumsum(prices)
+    cma = cumsum / (np.arange(len(prices)) + 1)
+    return cma
+
+# Other Moving Average Methods
+# Function to calculate Parabolic Weighted Moving Average (PWMA)
+def parabolic_weighted_moving_average(prices, n=14):
+    weights = np.array([(n-i)**2 for i in range(n)])
+    return np.convolve(prices, weights/weights.sum(), mode='valid')
+
+# Function to calculate Regularized Exponential Moving Average (REMA)
+def REMA(prices, alpha=0.1, lambda_=0.1):
+    rema = [prices[0]]
+    penalty = 0
+
+    for t in range(1, len(prices)):
+        second_derivative = prices[t] - 2 * prices[t-1] + prices[t-2] if t-2 >= 0 else 0
+        penalty = lambda_ * second_derivative
+        current_rema = alpha * prices[t] + (1 - alpha) * rema[-1] - penalty
+        rema.append(current_rema)
+
+    return rema
+
+# Function to calculate Weighted Moving Average (WMA)
+def weighted_moving_average(data, periods):
+    weights = np.arange(1, periods + 1)
+    wma = data.rolling(periods).apply(lambda x: np.dot(x, weights) / weights.sum(), raw=True)
+    return wma
+
+# Function to calculate Hull Moving Average (HMA)
+def hull_moving_average(data, periods):
+    wma_half_period = weighted_moving_average(data, int(periods / 2))
+    wma_full_period = weighted_moving_average(data, periods)
+    hma = weighted_moving_average(2 * wma_half_period - wma_full_period, int(np.sqrt(periods)))
+    return hma
+
+# Function to calculate Harmonic Moving Average (HMA) to avoid conflict with Hull
+def harmonic_moving_average(data, period):
+    def harmonic_mean(prices):
+        return period / np.sum(1.0 / prices)
+
+    hma_values = []
+    for i in range(period - 1, len(data)):
+        hma_values.append(harmonic_mean(data[i - period + 1:i + 1]))
+
+    return [np.nan] * (period - 1) + hma_values
+
+# Function to calculate Fractal Adaptive Moving Average (FRAMA)
+def calculate_FRAMA(data, batch=10):
+    InputPrice = data['Close'].values
+    Length = len(InputPrice)
+    Filt = np.array(InputPrice)
+
+    for i in range(2 * batch, Length):
+        v1 = InputPrice[i-2*batch:i - batch]
+        v2 = InputPrice[i - batch:i]
+
+        H1 = np.max(v1)
+        L1 = np.min(v1)
+        N1 = (H1 - L1) / batch
+
+        H2 = np.max(v2)
+        L2 = np.min(v2)
+        N2 = (H2 - L2) / batch
+
+        H = np.max([H1, H2])
+        L = np.min([L1, L2])
+        N3 = (H - L) / (2 * batch)
+
+        Dimen = 0
+        if N1 > 0 and N2 > 0 and N3 > 0:
+            Dimen = (np.log(N1 + N2) - np.log(N3)) / np.log(2)
+
+        alpha = np.exp(-4.6 * Dimen - 1)
+        alpha = np.clip(alpha, 0.1, 1)
+
+        Filt[i] = alpha * InputPrice[i] + (1 - alpha) * Filt[i-1]
+
+    data['FRAMA'] = Filt
+    return data
+
+# Function to calculate Exponential Moving Average (EMA)
+def calculate_EMA(prices, period):
+    alpha = 2 / (period + 1)
+    EMA = [prices[0]]
+    for price in prices[1:]:
+        EMA.append((price - EMA[-1]) * alpha + EMA[-1])
+    return EMA
+
+# Function to calculate Zero Lag Exponential Moving Average (ZLEMA)
+def calculate_ZLEMA(prices, period):
+    lag = period // 2
+    adjusted_prices = [2 * prices[i] - (prices[i - lag] if i >= lag else prices[0]) for i in range(len(prices))]
+    ZLEMA = calculate_EMA(adjusted_prices, period)
+    return ZLEMA
+
+# Function to calculate Chande Momentum Oscillator (CMO)
+def calculate_CMO(prices, period):
+    deltas = np.diff(prices)
+    sum_gains = np.cumsum(np.where(deltas >= 0, deltas, 0))
+    sum_losses = np.abs(np.cumsum(np.where(deltas < 0, deltas, 0)))
+
+    cmo = 100 * (sum_gains - sum_losses) / (sum_gains + sum_losses)
+    return np.insert(cmo, 0, 0)  # Add a zero at the beginning for alignment
+
+# Function to calculate Variable Index Dynamic Average (VIDYA)
+def calculate_VIDYA(prices, period):
+    cmo_values = calculate_CMO(prices, period)
+    vidya = [prices[0]]
+
+    for i in range(1, len(prices)):
+        alpha = abs(cmo_values[i]) / 100  # Normalize CMO to [0, 1]
+        vidya.append((1 - alpha) * vidya[-1] + alpha * prices[i])
+
+    return vidya
+
+# Function to calculate Arnaud Legoux Moving Average (ALMA)
+def calculate_ALMA(prices, period, offset=0.85, sigma=6):
+    m = np.floor(offset * (period - 1))
+    s = period / sigma
+    alma = []
+
+    for i in range(period - 1, len(prices)):
+        weights = [np.exp(- (j - m)**2 / (2 * s * s)) for j in range(period)]
+        sum_weights = sum(weights)
+        normalized_weights = [w/sum_weights for w in weights]
+
+        window = prices[i-period+1:i+1]
+        alma_value = sum([normalized_weights[j] * window[j] for j in range(period)])
+        alma.append(alma_value)
+
+    return [None]*(period-1) + alma  # Pad the beginning with None for alignment
+
+# Function to calculate Adaptive Period Moving Average (APMA)
+def adaptive_period_moving_average(prices, min_period=5, max_period=30):
+    atr = np.zeros_like(prices)
+    adjusted_periods = np.zeros_like(prices)
+    moving_averages = np.full_like(prices, np.nan)  # Initialize with NaN values
+
+    for i in range(1, len(prices)):
+        atr[i] = atr[i-1] + (abs(prices[i] - prices[i-1]) - atr[i-1]) / 14
+
+        min_volatility = atr[1:i+1].min()
+        max_volatility = atr[1:i+1].max()
+
+        if max_volatility == min_volatility:
+            adjusted_period = min_period
+        else:
+            adjusted_period = int(((max_period - min_period) / (max_volatility - min_volatility)) * (atr[i] - min_volatility) + min_period)
+
+        adjusted_periods[i] = adjusted_period
+
+        if i >= adjusted_period:
+            moving_averages[i] = np.mean(prices[i-adjusted_period+1:i+1])
+
+    return moving_averages
+
+# Function to calculate Rainbow Moving Average (Rainbow EMA)
+def calculate_rainbow_ema(data, lookback_periods):
+    for lookback in lookback_periods:
+        data[f'EMA{lookback}'] = data['Close'].ewm(span=lookback).mean()
+    return data
+
+# Function to calculate Wilders Moving Average
+def wilders_moving_average(prices, period):
+    wilder = [prices[0]]
+    for price in prices[1:]:
+        wilder_value = ((wilder[-1] * (period - 1)) + price) / period
+        wilder.append(wilder_value)
+    return wilder
+
+# Function to calculate Smoothed Moving Average (SMMA)
+def calculate_SMMA(prices, n):
+    SMMA = [np.nan] * (n-1)  # Fill the initial n-1 values with NaN
+    SMMA.append(sum(prices[:n]) / n)
+    for i in range(n, len(prices)):
+        smma_value = (SMMA[-1] * (n - 1) + prices[i]) / n
+        SMMA.append(smma_value)
+    return SMMA
+
+# Function to calculate Least Squares Moving Average (LSMA)
+def calculate_LSMA(prices, period):
+    n = period
+    x = np.array(range(1, n+1))
+
+    LSMA = []
+    for i in range(len(prices) - period + 1):
+        y = prices[i:i+period]
+        m = (n*np.sum(x*y) - np.sum(x)*np.sum(y)) / (n*np.sum(x**2) - np.sum(x)**2)
+        c = (np.sum(y) - m*np.sum(x)) / n
+        LSMA.append(m * n + c)  # The projected value at the end of the period
+
+    # Padding the beginning with NaNs for alignment
+    LSMA = [np.nan] * (period-1) + LSMA
+    return LSMA
+
+# Function to calculate Welch's Moving Average (Modified Moving Average, MMA)
+def calculate_MMA(prices, period):
+    MMA = [sum(prices[:period]) / period]  # Start with the SMA for the first value
+    for t in range(period, len(prices)):
+        MMA.append((prices[t] + (period - 1) * MMA[-1]) / period)
+    return [None]*(period-1) + MMA  # Pad the beginning with None for alignment
+
+# Function to calculate Sin-weighted Moving Average (SinWMA)
+def calculate_SinWMA(prices, period):
+    weights = [np.sin(np.pi * i / (period + 1)) for i in range(1, period+1)]
+    sum_weights = sum(weights)
+    normalized_weights = [w/sum_weights for w in weights]
+
+    SinWMA = []
+    for t in range(period - 1, len(prices)):
+        window = prices[t-period+1:t+1]
+        SinWMA.append(sum([normalized_weights[i] * window[i] for i in range(period)]))
+
+    return [None]*(period-1) + SinWMA  # Pad the beginning with None for alignment
+
+# Function to calculate Median Moving Average (MedMA)
+def calculate_MedMA(prices, window):
+    medians = []
+    for i in range(len(prices)):
+        if i < window - 1:
+            medians.append(np.nan)
+        else:
+            median = np.median(prices[i - window + 1: i + 1])
+            medians.append(median)
+    return medians
 
-# Dynamic input for moving averages
-ma_short_period = st.sidebar.number_input('Short-term Moving Average Period', min_value=1, value=20)
-ma_long_period = st.sidebar.number_input('Long-term Moving Average Period', min_value=1, value=50)
+# Function to calculate Geometric Moving Average (GMA)
+def calculate_GMA(prices, window):
+    gm_avg = []
+    for i in range(len(prices)):
+        if i < window - 1:
+            gm_avg.append(np.nan)
+        else:
+            product = np.prod(prices[i - window + 1: i + 1])
+            gma_value = product ** (1/window)
+            gm_avg.append(gma_value)
+    return gm_avg
 
-if st.sidebar.button('Run Analysis'):
-    run_analysis = True
-else:
-    run_analysis = False
+# Function to calculate Elastic Volume Weighted Moving Average (eVWMA)
+def calculate_eVWMA(prices, volumes, window):
+    evwma_values = []
+    for i in range(len(prices)):
+        if i < window:
+            evwma_values.append(np.nan)
+        else:
+            price_subset = prices[i-window+1:i+1]
+            volume_subset = volumes[i-window+1:i+1]
+            numerator = sum([p * v for p, v in zip(price_subset, volume_subset)])
+            denominator = sum(volume_subset)
+            evwma = numerator / denominator
+            evwma_values.append(evwma)
+    return evwma_values
 
-st.sidebar.header('Candlestick Patterns')
-selected_patterns = {name: st.sidebar.checkbox(name, value=True) for name, func in pattern_funcs}
+# Function to calculate McGinley Dynamic (MD)
+def calculate_mcginley_dynamic(prices, n):
+    MD = [prices[0]]
+    for i in range(1, len(prices)):
+        md_value = MD[-1] + (prices[i] - MD[-1]) / (n * (prices[i] / MD[-1])**4)
+        MD.append(md_value)
+    return MD
 
-if run_analysis:
-    data = yf.download(symbol, start=start_date, end=end_date)
+# Function to calculate Anchored Moving Average (AMA)
+from datetime import datetime
+
+def calculate_AMA(prices, anchor_date, data):
+    # Ensure the anchor_date is a pandas Timestamp
+    anchor_date = pd.to_datetime(anchor_date)
+
+    try:
+        anchor_idx = data.index.get_loc(anchor_date)
+    except KeyError:
+        # If the exact date is not found, find the nearest available date
+        anchor_date = data.index[data.index.get_loc(anchor_date, method='nearest')]
+        anchor_idx = data.index.get_loc(anchor_date)
+
+    AMA = []
+
+    for i in range(len(prices)):
+        if i < anchor_idx:
+            AMA.append(None)
+        else:
+            AMA.append(sum(prices[anchor_idx:i+1]) / (i - anchor_idx + 1))
+
+    return AMA
+
+# Function to calculate Filtered Moving Average (FMA)
+def filtered_moving_average(prices, n=14):
+    # Define filter weights (for simplicity, we'll use equal weights similar to SMA)
+    w = np.ones(n) / n
+    return np.convolve(prices, w, mode='valid')
+
+# Sidebar for user inputs
+st.sidebar.header("Select Parameters")
+
+# Ticker input with tooltip
+ticker_symbol = st.sidebar.text_input(
+    "Ticker Symbol", 
+    value=st.session_state.get('ticker_symbol', 'AAPL'),
+    help="Enter the stock ticker symbol (e.g., AAPL for Apple)."
+)
+
+# Date range inputs with tooltip
+start_date = st.sidebar.date_input(
+    "Start Date", 
+    value=st.session_state.get('start_date', pd.to_datetime("2020-01-01")),
+    help="Select the start date for fetching the stock data."
+)
+end_date = st.sidebar.date_input(
+    "End Date", 
+    value=st.session_state.get('end_date', pd.to_datetime("2024-01-01")),
+    help="Select the end date for fetching the stock data."
+)
+
+# Fetch Data button
+if st.sidebar.button('Fetch Data'):
+    # Only fetch if the ticker or date range has changed
+    if (
+        ticker_symbol != st.session_state.get('ticker_symbol') or 
+        start_date != st.session_state.get('start_date') or 
+        end_date != st.session_state.get('end_date')
+    ):
+        data = get_data(ticker_symbol, start_date, end_date)
+        st.session_state['data'] = data
+        st.session_state['ticker_symbol'] = ticker_symbol
+        st.session_state['start_date'] = start_date
+        st.session_state['end_date'] = end_date
+        st.session_state['price_plot'] = create_price_plot(data, ticker_symbol)
+        st.session_state['current_fig'] = st.session_state['price_plot']
+
+# Check if data is fetched and stored in session state
+if 'data' in st.session_state:
+    data = st.session_state['data']
+    
+    # Moving average method selection
+    st.sidebar.header("Moving Average Methods")
+    
+    # SMA with tooltip
+    use_sma = st.sidebar.checkbox(
+        'Simple Moving Average (SMA)', 
+        value=st.session_state.get('use_sma', False),
+        help="Select to apply Simple Moving Average (SMA) to the stock price."
+    )
+    sma_period = st.sidebar.number_input(
+        'SMA Period', 
+        min_value=1, 
+        value=st.session_state.get('sma_period', 50), 
+        step=1, 
+        disabled=not use_sma,
+        help="Specify the period (in days) for the SMA."
+    )
+    
+    # EMA with tooltip
+    use_ema = st.sidebar.checkbox(
+        'Exponential Moving Average (EMA)', 
+        value=st.session_state.get('use_ema', False),
+        help="Select to apply Exponential Moving Average (EMA) to the stock price."
+    )
+    ema_period = st.sidebar.number_input(
+        'EMA Period', 
+        min_value=1, 
+        value=st.session_state.get('ema_period', 50), 
+        step=1, 
+        disabled=not use_ema,
+        help="Specify the period (in days) for the EMA."
+    )
+
+    # WMA with tooltip
+    use_wma = st.sidebar.checkbox(
+        'Weighted Moving Average (WMA)', 
+        value=st.session_state.get('use_wma', False),
+        help="Select to apply Weighted Moving Average (WMA) to the stock price."
+    )
+    wma_period = st.sidebar.number_input(
+        'WMA Period', 
+        min_value=1, 
+        value=st.session_state.get('wma_period', 50), 
+        step=1, 
+        disabled=not use_wma,
+        help="Specify the period (in days) for the WMA."
+    )
+
+    # DEMA with tooltip
+    use_dema = st.sidebar.checkbox(
+        'Double Exponential Moving Average (DEMA)', 
+        value=st.session_state.get('use_dema', False),
+        help="Select to apply Double Exponential Moving Average (DEMA) to the stock price."
+    )
+    dema_period = st.sidebar.number_input(
+        'DEMA Period', 
+        min_value=1, 
+        value=st.session_state.get('dema_period', 50), 
+        step=1, 
+        disabled=not use_dema,
+        help="Specify the period (in days) for the DEMA."
+    )
+
+    # TEMA with tooltip
+    use_tema = st.sidebar.checkbox(
+        'Triple Exponential Moving Average (TEMA)', 
+        value=st.session_state.get('use_tema', False),
+        help="Select to apply Triple Exponential Moving Average (TEMA) to the stock price."
+    )
+    tema_period = st.sidebar.number_input(
+        'TEMA Period', 
+        min_value=1, 
+        value=st.session_state.get('tema_period', 50), 
+        step=1, 
+        disabled=not use_tema,
+        help="Specify the period (in days) for the TEMA."
+    )
+
+    # VAMA with tooltip
+    use_vama = st.sidebar.checkbox(
+        'Volume-Adjusted Moving Average (VAMA)', 
+        value=st.session_state.get('use_vama', False),
+        help="Select to apply Volume-Adjusted Moving Average (VAMA) to the stock price."
+    )
+    vama_period = st.sidebar.number_input(
+        'VAMA Period', 
+        min_value=1, 
+        value=st.session_state.get('vama_period', 50), 
+        step=1, 
+        disabled=not use_vama,
+        help="Specify the period (in days) for the VAMA."
+    )
+
+    # KAMA with tooltip
+    use_kama = st.sidebar.checkbox(
+        'Kaufman Adaptive Moving Average (KAMA)', 
+        value=st.session_state.get('use_kama', False),
+        help="Select to apply Kaufman Adaptive Moving Average (KAMA) to the stock price."
+    )
+    kama_period = st.sidebar.number_input(
+        'KAMA Period', 
+        min_value=1, 
+        value=st.session_state.get('kama_period', 10), 
+        step=1, 
+        disabled=not use_kama,
+        help="Specify the efficiency ratio period (in days) for the KAMA."
+    )
+    fastest_period = st.sidebar.number_input(
+        'Fastest SC Period', 
+        min_value=1, 
+        value=st.session_state.get('fastest_period', 2), 
+        step=1, 
+        disabled=not use_kama,
+        help="Specify the fastest smoothing constant period."
+    )
+    slowest_period = st.sidebar.number_input(
+        'Slowest SC Period', 
+        min_value=1, 
+        value=st.session_state.get('slowest_period', 30), 
+        step=1, 
+        disabled=not use_kama,
+        help="Specify the slowest smoothing constant period."
+    )
+
+    # TMA with tooltip
+    use_tma = st.sidebar.checkbox(
+        'Triangular Moving Average (TMA)', 
+        value=st.session_state.get('use_tma', False),
+        help="Select to apply Triangular Moving Average (TMA) to the stock price."
+    )
+    tma_period = st.sidebar.number_input(
+        'TMA Period', 
+        min_value=1, 
+        value=st.session_state.get('tma_period', 20), 
+        step=1, 
+        disabled=not use_tma,
+        help="Specify the period (in days) for the TMA."
+    )
+
+    # Hull MA with tooltip
+    use_hull_ma = st.sidebar.checkbox(
+        'Hull Moving Average (HMA)', 
+        value=st.session_state.get('use_hull_ma', False),
+        help="Select to apply Hull Moving Average (HMA) to the stock price."
+    )
+    hull_ma_period = st.sidebar.number_input(
+        'HMA Period', 
+        min_value=1, 
+        value=st.session_state.get('hull_ma_period', 120), 
+        step=1, 
+        disabled=not use_hull_ma,
+        help="Specify the period (in days) for the Hull Moving Average."
+    )
+
+    # Harmonic MA with tooltip
+    use_harmonic_ma = st.sidebar.checkbox(
+        'Harmonic Moving Average (HMA)', 
+        value=st.session_state.get('use_harmonic_ma', False),
+        help="Select to apply Harmonic Moving Average (HMA) to the stock price."
+    )
+    harmonic_ma_period = st.sidebar.number_input(
+        'HMA Period', 
+        min_value=1, 
+        value=st.session_state.get('harmonic_ma_period', 120), 
+        step=1, 
+        disabled=not use_harmonic_ma,
+        help="Specify the period (in days) for the Harmonic Moving Average."
+    )
+
+    # FRAMA with tooltip
+    use_frama = st.sidebar.checkbox(
+        'Fractal Adaptive Moving Average (FRAMA)', 
+        value=st.session_state.get('use_frama', False),
+        help="Select to apply Fractal Adaptive Moving Average (FRAMA) to the stock price."
+    )
+    frama_batch = st.sidebar.number_input(
+        'FRAMA Batch Size', 
+        min_value=1, 
+        value=st.session_state.get('frama_batch', 10), 
+        step=1, 
+        disabled=not use_frama,
+        help="Specify the batch size for FRAMA calculation."
+    )
+
+    # ZLEMA with tooltip
+    use_zlema = st.sidebar.checkbox(
+        'Zero Lag Exponential Moving Average (ZLEMA)', 
+        value=st.session_state.get('use_zlema', False),
+        help="Select to apply Zero Lag Exponential Moving Average (ZLEMA) to the stock price."
+    )
+    zlema_period = st.sidebar.number_input(
+        'ZLEMA Period', 
+        min_value=1, 
+        value=st.session_state.get('zlema_period', 28), 
+        step=1, 
+        disabled=not use_zlema,
+        help="Specify the period (in days) for the ZLEMA."
+    )
+
+    # VIDYA with tooltip
+    use_vidya = st.sidebar.checkbox(
+        'Variable Index Dynamic Average (VIDYA)', 
+        value=st.session_state.get('use_vidya', False),
+        help="Select to apply Variable Index Dynamic Average (VIDYA) to the stock price."
+    )
+    vidya_period = st.sidebar.number_input(
+        'VIDYA Period', 
+        min_value=1, 
+        value=st.session_state.get('vidya_period', 14), 
+        step=1, 
+        disabled=not use_vidya,
+        help="Specify the period (in days) for the VIDYA."
+    )
+
+    # ALMA with tooltip
+    use_alma = st.sidebar.checkbox(
+        'Arnaud Legoux Moving Average (ALMA)', 
+        value=st.session_state.get('use_alma', False),
+        help="Select to apply Arnaud Legoux Moving Average (ALMA) to the stock price."
+    )
+    alma_period = st.sidebar.number_input(
+        'ALMA Period', 
+        min_value=1, 
+        value=st.session_state.get('alma_period', 36), 
+        step=1, 
+        disabled=not use_alma,
+        help="Specify the period (in days) for the ALMA."
+    )
+    alma_offset = st.sidebar.number_input(
+        'ALMA Offset', 
+        min_value=0.0, 
+        max_value=1.0, 
+        value=st.session_state.get('alma_offset', 0.85), 
+        step=0.01, 
+        disabled=not use_alma,
+        help="Specify the offset for the ALMA (0 to 1)."
+    )
+    alma_sigma = st.sidebar.number_input(
+        'ALMA Sigma', 
+        min_value=1, 
+        value=st.session_state.get('alma_sigma', 6), 
+        step=1, 
+        disabled=not use_alma,
+        help="Specify the sigma for the ALMA."
+    )
+
+    # MAMA and FAMA with tooltip
+    use_mama_fama = st.sidebar.checkbox(
+        'MESA Adaptive Moving Average (MAMA) & FAMA', 
+        value=st.session_state.get('use_mama_fama', False),
+        help="Select to apply MESA Adaptive Moving Average (MAMA) and Following Adaptive Moving Average (FAMA) to the stock price."
+    )
+    mama_fast_limit = st.sidebar.number_input(
+        'MAMA Fast Limit', 
+        min_value=0.0, 
+        max_value=1.0, 
+        value=st.session_state.get('mama_fast_limit', 0.5), 
+        step=0.01, 
+        disabled=not use_mama_fama,
+        help="Specify the fast limit for MAMA (0 to 1)."
+    )
+    mama_slow_limit = st.sidebar.number_input(
+        'MAMA Slow Limit', 
+        min_value=0.0, 
+        max_value=1.0, 
+        value=st.session_state.get('mama_slow_limit', 0.05), 
+        step=0.01, 
+        disabled=not use_mama_fama,
+        help="Specify the slow limit for MAMA (0 to 1)."
+    )
+
+    # APMA with tooltip
+    use_apma = st.sidebar.checkbox(
+        'Adaptive Period Moving Average (APMA)', 
+        value=st.session_state.get('use_apma', False),
+        help="Select to apply Adaptive Period Moving Average (APMA) to the stock price."
+    )
+    apma_min_period = st.sidebar.number_input(
+        'APMA Min Period', 
+        min_value=1, 
+        value=st.session_state.get('apma_min_period', 5), 
+        step=1, 
+        disabled=not use_apma,
+        help="Specify the minimum period for the APMA."
+    )
+    apma_max_period = st.sidebar.number_input(
+        'APMA Max Period', 
+        min_value=1, 
+        value=st.session_state.get('apma_max_period', 30), 
+        step=1, 
+        disabled=not use_apma,
+        help="Specify the maximum period for the APMA."
+    )
+
+    # Rainbow EMA with tooltip
+    use_rainbow_ema = st.sidebar.checkbox(
+        'Rainbow Moving Average (EMA)', 
+        value=st.session_state.get('use_rainbow_ema', False),
+        help="Select to apply Rainbow Moving Average (EMA) with multiple lookback periods to the stock price."
+    )
+    rainbow_lookback_periods = st.sidebar.multiselect(
+        'Rainbow Lookback Periods', 
+        options=[2, 4, 8, 16, 32, 64, 128, 192, 320, 512],
+        default=st.session_state.get('rainbow_lookback_periods', [2, 4, 8, 16, 32, 64, 128]),
+        disabled=not use_rainbow_ema,
+        help="Select multiple lookback periods for the Rainbow EMA."
+    )
+
+    # Wilders MA with tooltip
+    use_wilders_ma = st.sidebar.checkbox(
+        'Wilders Moving Average (Wilder\'s MA)', 
+        value=st.session_state.get('use_wilders_ma', False),
+        help="Select to apply Wilder's Moving Average to the stock price."
+    )
+    wilders_ma_period = st.sidebar.number_input(
+        'Wilders MA Period', 
+        min_value=1, 
+        value=st.session_state.get('wilders_ma_period', 14), 
+        step=1, 
+        disabled=not use_wilders_ma,
+        help="Specify the period (in days) for Wilder's Moving Average."
+    )
+
+    # SMMA with tooltip
+    use_smma = st.sidebar.checkbox(
+        'Smoothed Moving Average (SMMA)', 
+        value=st.session_state.get('use_smma', False),
+        help="Select to apply Smoothed Moving Average (SMMA) to the stock price."
+    )
+    smma_period = st.sidebar.number_input(
+        'SMMA Period', 
+        min_value=1, 
+        value=st.session_state.get('smma_period', 28), 
+        step=1, 
+        disabled=not use_smma,
+        help="Specify the period (in days) for the SMMA."
+    )
+
+    # GMMA with tooltip
+    use_gmma = st.sidebar.checkbox(
+        'Guppy Multiple Moving Average (GMMA)', 
+        value=st.session_state.get('use_gmma', False),
+        help="Select to apply Guppy Multiple Moving Average (GMMA) to the stock price."
+    )
+    gmma_short_periods = st.sidebar.multiselect(
+        'GMMA Short Periods', 
+        options=[3, 5, 8, 10, 12, 15],
+        default=st.session_state.get('gmma_short_periods', [3, 5, 8, 10, 12, 15]),
+        disabled=not use_gmma,
+        help="Select the short-term periods for GMMA."
+    )
+    gmma_long_periods = st.sidebar.multiselect(
+        'GMMA Long Periods', 
+        options=[30, 35, 40, 45, 50, 60],
+        default=st.session_state.get('gmma_long_periods', [30, 35, 40, 45, 50, 60]),
+        disabled=not use_gmma,
+        help="Select the long-term periods for GMMA."
+    )
+
+    # LSMA with tooltip
+    use_lsma = st.sidebar.checkbox(
+        'Least Squares Moving Average (LSMA)', 
+        value=st.session_state.get('use_lsma', False),
+        help="Select to apply Least Squares Moving Average (LSMA) to the stock price."
+    )
+    lsma_period = st.sidebar.number_input(
+        'LSMA Period', 
+        min_value=1, 
+        value=st.session_state.get('lsma_period', 28), 
+        step=1, 
+        disabled=not use_lsma,
+        help="Specify the period (in days) for the LSMA."
+    )
+
+    # MMA (Welch's MMA) with tooltip
+    use_mma = st.sidebar.checkbox(
+        'Welch\'s Moving Average (MMA)', 
+        value=st.session_state.get('use_mma', False),
+        help="Select to apply Welch\'s Moving Average (Modified Moving Average) to the stock price."
+    )
+    mma_period = st.sidebar.number_input(
+        'MMA Period', 
+        min_value=1, 
+        value=st.session_state.get('mma_period', 14), 
+        step=1, 
+        disabled=not use_mma,
+        help="Specify the period (in days) for the MMA."
+    )
+
+    # SinWMA with tooltip
+    use_sinwma = st.sidebar.checkbox(
+        'Sin-weighted Moving Average (SinWMA)', 
+        value=st.session_state.get('use_sinwma', False),
+        help="Select to apply Sin-weighted Moving Average (SinWMA) to the stock price."
+    )
+    sinwma_period = st.sidebar.number_input(
+        'SinWMA Period', 
+        min_value=1, 
+        value=st.session_state.get('sinwma_period', 21), 
+        step=1, 
+        disabled=not use_sinwma,
+        help="Specify the period (in days) for the SinWMA."
+    )
+
+    # MedMA with tooltip
+    use_medma = st.sidebar.checkbox(
+        'Median Moving Average (MedMA)', 
+        value=st.session_state.get('use_medma', False),
+        help="Select to apply Median Moving Average (MedMA) to the stock price."
+    )
+    medma_period = st.sidebar.number_input(
+        'MedMA Period', 
+        min_value=1, 
+        value=st.session_state.get('medma_period', 20), 
+        step=1, 
+        disabled=not use_medma,
+        help="Specify the period (in days) for the MedMA."
+    )
+
+    # GMA with tooltip
+    use_gma = st.sidebar.checkbox(
+        'Geometric Moving Average (GMA)', 
+        value=st.session_state.get('use_gma', False),
+        help="Select to apply Geometric Moving Average (GMA) to the stock price."
+    )
+    gma_period = st.sidebar.number_input(
+        'GMA Period', 
+        min_value=1, 
+        value=st.session_state.get('gma_period', 20), 
+        step=1, 
+        disabled=not use_gma,
+        help="Specify the period (in days) for the GMA."
+    )
+
+    # eVWMA with tooltip
+    use_evwma = st.sidebar.checkbox(
+        'Elastic Volume Weighted Moving Average (eVWMA)', 
+        value=st.session_state.get('use_evwma', False),
+        help="Select to apply Elastic Volume Weighted Moving Average (eVWMA) to the stock price."
+    )
+    evwma_period = st.sidebar.number_input(
+        'eVWMA Period', 
+        min_value=1, 
+        value=st.session_state.get('evwma_period', 20), 
+        step=1, 
+        disabled=not use_evwma,
+        help="Specify the period (in days) for the eVWMA."
+    )
+
+    # REMA with tooltip
+    use_rema = st.sidebar.checkbox(
+        'Regularized Exponential Moving Average (REMA)', 
+        value=st.session_state.get('use_rema', False),
+        help="Select to apply Regularized Exponential Moving Average (REMA) to the stock price."
+    )
+    rema_alpha = st.sidebar.number_input(
+        'REMA Alpha', 
+        min_value=0.0, 
+        max_value=1.0, 
+        value=st.session_state.get('rema_alpha', 0.1), 
+        step=0.01, 
+        disabled=not use_rema,
+        help="Specify the alpha value for the REMA (0 to 1)."
+    )
+    rema_lambda = st.sidebar.number_input(
+        'REMA Lambda', 
+        min_value=0.0, 
+        max_value=1.0, 
+        value=st.session_state.get('rema_lambda', 0.1), 
+        step=0.01, 
+        disabled=not use_rema,
+        help="Specify the lambda value for the REMA (0 to 1)."
+    )
+
+    # PWMA with tooltip
+    use_pwma = st.sidebar.checkbox(
+        'Parabolic Weighted Moving Average (PWMA)', 
+        value=st.session_state.get('use_pwma', False),
+        help="Select to apply Parabolic Weighted Moving Average (PWMA) to the stock price."
+    )
+    pwma_period = st.sidebar.number_input(
+        'PWMA Period', 
+        min_value=1, 
+        value=st.session_state.get('pwma_period', 14), 
+        step=1, 
+        disabled=not use_pwma,
+        help="Specify the period (in days) for the PWMA."
+    )
+
+    # JMA with tooltip
+    use_jma = st.sidebar.checkbox(
+        'Jurik Moving Average (JMA)', 
+        value=st.session_state.get('use_jma', False),
+        help="Select to apply Jurik Moving Average (JMA) to the stock price."
+    )
+    jma_period = st.sidebar.number_input(
+        'JMA Period', 
+        min_value=1, 
+        value=st.session_state.get('jma_period', 28), 
+        step=1, 
+        disabled=not use_jma,
+        help="Specify the period (in days) for the JMA."
+    )
+    jma_phase = st.sidebar.number_input(
+        'JMA Phase', 
+        min_value=-100.0, 
+        max_value=100.0, 
+        value=st.session_state.get('jma_phase', 0.0), 
+        step=0.1, 
+        disabled=not use_jma,
+        help="Specify the phase for the JMA (-100 to 100)."
+    )
+
+    # EPMA with tooltip
+    use_epma = st.sidebar.checkbox(
+        'End Point Moving Average (EPMA)', 
+        value=st.session_state.get('use_epma', False),
+        help="Select to apply End Point Moving Average (EPMA) to the stock price."
+    )
+    epma_period = st.sidebar.number_input(
+        'EPMA Period', 
+        min_value=1, 
+        value=st.session_state.get('epma_period', 28), 
+        step=1, 
+        disabled=not use_epma,
+        help="Specify the period (in days) for the EPMA."
+    )
+
+    # CMA with tooltip
+    use_cma = st.sidebar.checkbox(
+        'Chande Moving Average (CMA)', 
+        value=st.session_state.get('use_cma', False),
+        help="Select to apply Chande Moving Average (CMA) to the stock price."
+    )
+    cma_period = len(data['Close'])
+
+    # McGinley Dynamic with tooltip
+    use_mcginley_dynamic = st.sidebar.checkbox(
+        'McGinley Dynamic', 
+        value=st.session_state.get('use_mcginley_dynamic', False),
+        help="Select to apply McGinley Dynamic to the stock price."
+    )
+    mcginley_dynamic_period = st.sidebar.number_input(
+        'McGinley Dynamic Period', 
+        min_value=1, 
+        value=st.session_state.get('mcginley_dynamic_period', 14), 
+        step=1, 
+        disabled=not use_mcginley_dynamic,
+        help="Specify the period (in days) for the McGinley Dynamic."
+    )
+
+    # Anchored Moving Average (AMA) with tooltip
+    use_ama = st.sidebar.checkbox(
+        'Anchored Moving Average (AMA)', 
+        value=st.session_state.get('use_ama', False),
+        help="Select to apply Anchored Moving Average (AMA) to the stock price."
+    )
+    ama_anchor_date = st.sidebar.date_input(
+        'AMA Anchor Date',
+        value=pd.to_datetime(st.session_state.get('ama_anchor_date', '2021-01-01')),
+        disabled=not use_ama,
+        help="Select the anchor date for the AMA."
+    )
+
+    # Filtered Moving Average (FMA) with tooltip
+    use_fma = st.sidebar.checkbox(
+        'Filtered Moving Average (FMA)', 
+        value=st.session_state.get('use_fma', False),
+        help="Select to apply Filtered Moving Average (FMA) to the stock price."
+    )
+    fma_period = st.sidebar.number_input(
+        'FMA Period', 
+        min_value=1, 
+        value=st.session_state.get('fma_period', 14), 
+        step=1, 
+        disabled=not use_fma,
+        help="Specify the period (in days) for the FMA."
+    )
+
+    # Grid toggle with tooltip
+    show_grid = st.sidebar.checkbox(
+        "Show Grid", 
+        value=True, 
+        help="Toggle to show or hide the grid on the plot."
+    )
     
-    if not data.empty:
-        # Calculate moving averages based on user input
-        data[f'MA{ma_short_period}'] = talib.SMA(data['Close'], timeperiod=ma_short_period)
-        data[f'MA{ma_long_period}'] = talib.SMA(data['Close'], timeperiod=ma_long_period)
-        
-        for pattern_name, pattern_func in pattern_funcs:
-            if selected_patterns[pattern_name]:
-                data[pattern_name] = pattern_func(data['Open'], data['High'], data['Low'], data['Close'])
-                pattern_dates = data[data[pattern_name] != 0].index
-
-                if len(pattern_dates) == 0:
-                    continue
-
-                fig = go.Figure()
-                
-                fig.add_trace(go.Candlestick(
-                    x=data.index,
-                    open=data['Open'],
-                    high=data['High'],
-                    low=data['Low'],
-                    close=data['Close'],
-                    name='Candlesticks',
-                    yaxis='y2'
-                ))
-
-                fig.add_trace(go.Scatter(
-                    x=data.index,
-                    y=data[f'MA{ma_short_period}'],
-                    mode='lines',
-                    line=dict(color='blue', width=1.5),
-                    name=f'{ma_short_period}-day MA',
-                    yaxis='y2'
-                ))
-
-                fig.add_trace(go.Scatter(
-                    x=data.index,
-                    y=data[f'MA{ma_long_period}'],
-                    mode='lines',
-                    line=dict(color='orange', width=1.5),
-                    name=f'{ma_long_period}-day MA',
-                    yaxis='y2'
-                ))
-
-                fig.add_trace(go.Bar(
-                    x=data.index,
-                    y=data['Volume'],
-                    name='Volume',
-                    yaxis='y',
-                    marker=dict(color='grey'),
-                    opacity=0.5
-                ))
-
-                for date in pattern_dates:
-                    fig.add_vline(x=date, line=dict(color='red', width=2, dash='dash'), name=pattern_name)
-
-                fig.update_layout(
-                    title=f"{symbol} Stock Price and {pattern_name} Pattern Detection",
-                    xaxis_title="Date",
-                    yaxis=dict(title='Volume'),
-                    yaxis2=dict(title='Price', overlaying='y', side='right'),
-                    legend_title="Legend",
-                    xaxis_rangeslider_visible=False,
-                    template='plotly_white'
-                )
-                
-                st.plotly_chart(fig)
-    else:
-        st.write("No data found for the given ticker and date range.")
+    # Run button to apply moving averages
+    if st.sidebar.button('Run'):
+        # Save the moving average settings to session state
+        st.session_state['use_sma'] = use_sma
+        st.session_state['sma_period'] = sma_period
+        st.session_state['use_ema'] = use_ema
+        st.session_state['ema_period'] = ema_period
+        st.session_state['use_wma'] = use_wma
+        st.session_state['wma_period'] = wma_period
+        st.session_state['use_dema'] = use_dema
+        st.session_state['dema_period'] = dema_period
+        st.session_state['use_tema'] = use_tema
+        st.session_state['tema_period'] = tema_period
+        st.session_state['use_vama'] = use_vama
+        st.session_state['vama_period'] = vama_period
+        st.session_state['use_kama'] = use_kama
+        st.session_state['kama_period'] = kama_period
+        st.session_state['fastest_period'] = fastest_period
+        st.session_state['slowest_period'] = slowest_period
+        st.session_state['use_tma'] = use_tma
+        st.session_state['tma_period'] = tma_period
+        st.session_state['use_hull_ma'] = use_hull_ma
+        st.session_state['hull_ma_period'] = hull_ma_period
+        st.session_state['use_harmonic_ma'] = use_harmonic_ma
+        st.session_state['harmonic_ma_period'] = harmonic_ma_period
+        st.session_state['use_frama'] = use_frama
+        st.session_state['frama_batch'] = frama_batch
+        st.session_state['use_zlema'] = use_zlema
+        st.session_state['zlema_period'] = zlema_period
+        st.session_state['use_vidya'] = use_vidya
+        st.session_state['vidya_period'] = vidya_period
+        st.session_state['use_alma'] = use_alma
+        st.session_state['alma_period'] = alma_period
+        st.session_state['alma_offset'] = alma_offset
+        st.session_state['alma_sigma'] = alma_sigma
+        st.session_state['use_mama_fama'] = use_mama_fama
+        st.session_state['mama_fast_limit'] = mama_fast_limit
+        st.session_state['mama_slow_limit'] = mama_slow_limit
+        st.session_state['use_apma'] = use_apma
+        st.session_state['apma_min_period'] = apma_min_period
+        st.session_state['apma_max_period'] = apma_max_period
+        st.session_state['use_rainbow_ema'] = use_rainbow_ema
+        st.session_state['rainbow_lookback_periods'] = rainbow_lookback_periods
+        st.session_state['use_wilders_ma'] = use_wilders_ma
+        st.session_state['wilders_ma_period'] = wilders_ma_period
+        st.session_state['use_smma'] = use_smma
+        st.session_state['smma_period'] = smma_period
+        st.session_state['use_gmma'] = use_gmma
+        st.session_state['gmma_short_periods'] = gmma_short_periods
+        st.session_state['gmma_long_periods'] = gmma_long_periods
+        st.session_state['use_lsma'] = use_lsma
+        st.session_state['lsma_period'] = lsma_period
+        st.session_state['use_mma'] = use_mma
+        st.session_state['mma_period'] = mma_period
+        st.session_state['use_sinwma'] = use_sinwma
+        st.session_state['sinwma_period'] = sinwma_period
+        st.session_state['use_medma'] = use_medma
+        st.session_state['medma_period'] = medma_period
+        st.session_state['use_gma'] = use_gma
+        st.session_state['gma_period'] = gma_period
+        st.session_state['use_evwma'] = use_evwma
+        st.session_state['evwma_period'] = evwma_period
+        st.session_state['use_rema'] = use_rema
+        st.session_state['rema_alpha'] = rema_alpha
+        st.session_state['rema_lambda'] = rema_lambda
+        st.session_state['use_pwma'] = use_pwma
+        st.session_state['pwma_period'] = pwma_period
+        st.session_state['use_jma'] = use_jma
+        st.session_state['jma_period'] = jma_period
+        st.session_state['jma_phase'] = jma_phase
+        st.session_state['use_epma'] = use_epma
+        st.session_state['epma_period'] = epma_period
+        st.session_state['use_cma'] = use_cma
+        st.session_state['use_mcginley_dynamic'] = use_mcginley_dynamic
+        st.session_state['mcginley_dynamic_period'] = mcginley_dynamic_period
+        st.session_state['use_ama'] = use_ama
+        st.session_state['ama_anchor_date'] = ama_anchor_date
+        st.session_state['use_fma'] = use_fma
+        st.session_state['fma_period'] = fma_period
+        # (Save all previous moving average settings here)
+        
+        # Start with the base price plot
+        fig = go.Figure(data=st.session_state['price_plot'].data)
+        
+        # Add JMA if selected
+        if use_jma:
+            st.session_state['JMA'] = jma(data['Close'], length=jma_period, phase=jma_phase)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['JMA'], mode='lines', name=f'JMA (n={jma_period}, phase={jma_phase})', line=dict(dash='dash', color='green')))
+        
+        # Add EPMA if selected
+        if use_epma:
+            st.session_state['EPMA'] = calculate_EPMA(data['Close'].tolist(), epma_period)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['EPMA'], mode='lines', name=f'EPMA (n={epma_period})', line=dict(dash='dash', color='blue')))
+
+        # Add CMA if selected
+        if use_cma:
+            st.session_state['CMA'] = calculate_CMA(data['Close'])
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['CMA'], mode='lines', name=f'CMA', line=dict(dash='dash', color='blue')))
+
+        # Add McGinley Dynamic if selected
+        if use_mcginley_dynamic:
+            st.session_state['McGinley_Dynamic'] = calculate_mcginley_dynamic(data['Close'].tolist(), mcginley_dynamic_period)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['McGinley_Dynamic'], mode='lines', name=f'McGinley Dynamic (n={mcginley_dynamic_period})', line=dict(dash='dash', color='orange')))
+
+        # Add AMA if selected
+        if use_ama:
+            st.session_state['AMA'] = calculate_AMA(data['Close'].tolist(), ama_anchor_date, data)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['AMA'], mode='lines', name=f'Anchored MA (Anchor Date={ama_anchor_date})', line=dict(dash='dash', color='red')))
+            fig.add_shape(type="line", x0=ama_anchor_date, y0=data['Close'].min(), x1=ama_anchor_date, y1=data['Close'].max(), line=dict(color="blue", width=2, dash="dash"))
+
+        # Add FMA if selected
+        if use_fma:
+            st.session_state['FMA'] = filtered_moving_average(data['Close'].values, fma_period)
+            fig.add_trace(go.Scatter(x=data.index, y=np.concatenate([np.array([np.nan]*(fma_period-1)), st.session_state['FMA']]), mode='lines', name=f'Filtered MA (n={fma_period})', line=dict(dash='dash', color='green')))
+
+        # Add SMA if selected
+        if use_sma:
+            st.session_state['SMA'] = data['Close'].rolling(window=sma_period).mean()
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['SMA'], mode='lines', name=f'{sma_period}-Day SMA', line=dict(dash='dash')))
+        
+        # Add EMA if selected
+        if use_ema:
+            st.session_state['EMA'] = data['Close'].ewm(span=ema_period, adjust=False).mean()
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['EMA'], mode='lines', name=f'{ema_period}-Day EMA', line=dict(dash='dash', color='green')))
+        
+        # Add WMA if selected
+        if use_wma:
+            weights = np.arange(1, wma_period + 1)
+            st.session_state['WMA'] = data['Close'].rolling(window=wma_period).apply(lambda prices: np.dot(prices, weights)/weights.sum(), raw=True)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['WMA'], mode='lines', name=f'{wma_period}-Day WMA', line=dict(dash='dash', color='orange')))
+        
+        # Add DEMA if selected
+        if use_dema:
+            data['EMA'] = data['Close'].ewm(span=dema_period, adjust=False).mean()
+            data['EMA2'] = data['EMA'].ewm(span=dema_period, adjust=False).mean()
+            st.session_state['DEMA'] = 2 * data['EMA'] - data['EMA2']
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['DEMA'], mode='lines', name=f'{dema_period}-Day DEMA', line=dict(dash='dash', color='red')))
+
+        # Add TEMA if selected
+        if use_tema:
+            data['EMA'] = data['Close'].ewm(span=tema_period, adjust=False).mean()
+            data['EMA2'] = data['EMA'].ewm(span=tema_period, adjust=False).mean()
+            data['EMA3'] = data['EMA2'].ewm(span=tema_period, adjust=False).mean()
+            st.session_state['TEMA'] = 3 * data['EMA'] - 3 * data['EMA2'] + data['EMA3']
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['TEMA'], mode='lines', name=f'{tema_period}-Day TEMA', line=dict(dash='dash', color='purple')))
+        
+        # Add VAMA if selected
+        if use_vama:
+            data['Volume_Price'] = data['Close'] * data['Volume']
+            st.session_state['VAMA'] = data['Volume_Price'].rolling(window=vama_period).sum() / data['Volume'].rolling(window=vama_period).sum()
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['VAMA'], mode='lines', name=f'{vama_period}-Day VAMA', line=dict(dash='dash', color='orange')))
+        
+        # Add KAMA if selected
+        if use_kama:
+            fastest_SC = 2 / (fastest_period + 1)
+            slowest_SC = 2 / (slowest_period + 1)
+            data['Change'] = abs(data['Close'] - data['Close'].shift(kama_period))
+            data['Volatility'] = data['Close'].diff().abs().rolling(window=kama_period).sum()
+            data['ER'] = data['Change'] / data['Volatility']
+            data['SC'] = (data['ER'] * (fastest_SC - slowest_SC) + slowest_SC)**2
+            data['KAMA'] = data['Close'].copy()
+            for i in range(kama_period, len(data)):
+                data['KAMA'].iloc[i] = data['KAMA'].iloc[i-1] + data['SC'].iloc[i] * (data['Close'].iloc[i] - data['KAMA'].iloc[i-1])
+            st.session_state['KAMA'] = data['KAMA']
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['KAMA'], mode='lines', name=f'KAMA (n={kama_period})', line=dict(dash='dash', color='green')))
+
+        # Add TMA if selected
+        if use_tma:
+            half_n = (tma_period + 1) // 2
+            data['Half_SMA'] = data['Close'].rolling(window=half_n).mean()
+            st.session_state['TMA'] = data['Half_SMA'].rolling(window=half_n).mean()
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['TMA'], mode='lines', name=f'TMA (n={tma_period})', line=dict(dash='dash', color='red')))
+
+        # Add Hull MA if selected
+        if use_hull_ma:
+            st.session_state['Hull_MA'] = hull_moving_average(data['Close'], hull_ma_period)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['Hull_MA'], mode='lines', name=f'Hull MA (n={hull_ma_period})', line=dict(dash='dash', color='green')))
+
+        # Add Harmonic MA if selected
+        if use_harmonic_ma:
+            st.session_state['Harmonic_MA'] = calculate_harmonic_moving_average(data['Close'].values, harmonic_ma_period)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['Harmonic_MA'], mode='lines', name=f'Harmonic MA (n={harmonic_ma_period})', line=dict(dash='dash', color='purple')))
+
+        # Add FRAMA if selected
+        if use_frama:
+            st.session_state['FRAMA'] = calculate_FRAMA(data, batch=frama_batch)['FRAMA']
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['FRAMA'], mode='lines', name=f'FRAMA (batch={frama_batch})', line=dict(dash='dash', color='green')))
+        
+        # Add ZLEMA if selected
+        if use_zlema:
+            st.session_state['ZLEMA'] = calculate_ZLEMA(data['Close'].tolist(), zlema_period)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['ZLEMA'], mode='lines', name=f'ZLEMA (n={zlema_period})', line=dict(dash='dash', color='red')))
+        
+        # Add VIDYA if selected
+        if use_vidya:
+            st.session_state['VIDYA'] = calculate_VIDYA(data['Close'].tolist(), vidya_period)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['VIDYA'], mode='lines', name=f'VIDYA (n={vidya_period})', line=dict(dash='dash', color='blue')))
+
+        # Add ALMA if selected
+        if use_alma:
+            st.session_state['ALMA'] = calculate_ALMA(data['Close'].tolist(), alma_period, offset=alma_offset, sigma=alma_sigma)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['ALMA'], mode='lines', name=f'ALMA (n={alma_period})', line=dict(dash='dash', color='purple')))
+
+        # Add MAMA and FAMA if selected
+        if use_mama_fama:
+            data['MAMA'], data['FAMA'] = talib.MAMA(data['Close'].values, fastlimit=mama_fast_limit, slowlimit=mama_slow_limit)
+            st.session_state['MAMA'] = data['MAMA']
+            st.session_state['FAMA'] = data['FAMA']
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['MAMA'], mode='lines', name=f'MAMA', line=dict(dash='dash', color='blue')))
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['FAMA'], mode='lines', name=f'FAMA', line=dict(dash='dash', color='red')))
+
+        # Add APMA if selected
+        if use_apma:
+            st.session_state['APMA'] = adaptive_period_moving_average(data['Close'].values, min_period=apma_min_period, max_period=apma_max_period)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['APMA'], mode='lines', name=f'APMA (min={apma_min_period}, max={apma_max_period})', line=dict(dash='dash', color='red')))
+        
+        # Add Rainbow EMA if selected
+        if use_rainbow_ema:
+            data = calculate_rainbow_ema(data, rainbow_lookback_periods)
+            colors = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet', 'black','gray','brown']
+            for i, lookback in enumerate(rainbow_lookback_periods):
+                fig.add_trace(go.Scatter(x=data.index, y=data[f'EMA{lookback}'], mode='lines', name=f'EMA {lookback}', line=dict(dash='solid', color=colors[i % len(colors)])))
+        
+        # Add Wilders MA if selected
+        if use_wilders_ma:
+            st.session_state['Wilders_MA'] = wilders_moving_average(data['Close'].tolist(), wilders_ma_period)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['Wilders_MA'], mode='lines', name=f'Wilders MA (n={wilders_ma_period})', line=dict(dash='dash', color='red')))
+        
+        # Add SMMA if selected
+        if use_smma:
+            st.session_state['SMMA'] = calculate_SMMA(data['Close'].tolist(), smma_period)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['SMMA'], mode='lines', name=f'SMMA (n={smma_period})', line=dict(dash='dash', color='red')))
+
+        # Add GMMA if selected
+        if use_gmma:
+            close_prices = data['Close'].tolist()
+            for period in gmma_short_periods:
+                data[f'EMA_{period}'] = calculate_EMA(close_prices, period)
+                fig.add_trace(go.Scatter(x=data.index, y=data[f'EMA_{period}'], mode='lines', name=f'GMMA Short EMA {period}', line=dict(dash='solid')))
+            for period in gmma_long_periods:
+                data[f'EMA_{period}'] = calculate_EMA(close_prices, period)
+                fig.add_trace(go.Scatter(x=data.index, y=data[f'EMA_{period}'], mode='lines', name=f'GMMA Long EMA {period}', line=dict(dash='dash')))
+
+        # Add LSMA if selected
+        if use_lsma:
+            st.session_state['LSMA'] = calculate_LSMA(data['Close'].tolist(), lsma_period)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['LSMA'], mode='lines', name=f'LSMA (n={lsma_period})', line=dict(dash='dash', color='blue')))
+
+        # Add MMA (Welch's MMA) if selected
+        if use_mma:
+            st.session_state['MMA'] = calculate_MMA(data['Close'].tolist(), mma_period)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['MMA'], mode='lines', name=f'MMA (n={mma_period})', line=dict(dash='dash', color='blue')))
+        
+        # Add SinWMA if selected
+        if use_sinwma:
+            st.session_state['SinWMA'] = calculate_SinWMA(data['Close'].tolist(), sinwma_period)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['SinWMA'], mode='lines', name=f'SinWMA (n={sinwma_period})', line=dict(dash='dash', color='green')))
+        
+        # Add MedMA if selected
+        if use_medma:
+            st.session_state['MedMA'] = calculate_MedMA(data['Close'].tolist(), medma_period)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['MedMA'], mode='lines', name=f'MedMA (n={medma_period})', line=dict(dash='dash', color='blue')))
+
+        # Add GMA if selected
+        if use_gma:
+            st.session_state['GMA'] = calculate_GMA(data['Close'].tolist(), gma_period)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['GMA'], mode='lines', name=f'GMA (n={gma_period})', line=dict(dash='dash', color='green')))
+
+        # Add eVWMA if selected
+        if use_evwma:
+            st.session_state['eVWMA'] = calculate_eVWMA(data['Close'], data['Volume'], evwma_period)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['eVWMA'], mode='lines', name=f'eVWMA (n={evwma_period})', line=dict(dash='dash', color='blue')))
+        
+        # Add REMA if selected
+        if use_rema:
+            st.session_state['REMA'] = REMA(data['Close'], alpha=rema_alpha, lambda_=rema_lambda)
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['REMA'], mode='lines', name=f'REMA (alpha={rema_alpha}, lambda={rema_lambda})', line=dict(dash='dash', color='red')))
+        
+        # Add PWMA if selected
+        if use_pwma:
+            pwma_values = parabolic_weighted_moving_average(data['Close'].values, pwma_period)
+            st.session_state['PWMA'] = np.concatenate([np.array([np.nan]*(pwma_period-1)), pwma_values])
+            fig.add_trace(go.Scatter(x=data.index, y=st.session_state['PWMA'], mode='lines', name=f'PWMA (n={pwma_period})', line=dict(dash='dash', color='red')))
+
+
+        # Update layout with grid toggle
+        fig.update_layout(
+            title=f'{ticker_symbol} Stock Price with Moving Averages',
+            xaxis_title='Date',
+            yaxis_title='Stock Price',
+            legend_title='Indicators',
+            template='plotly_white',
+            xaxis=dict(showgrid=show_grid),
+            yaxis=dict(showgrid=show_grid)
+        )
+    
+        # Store the updated figure in session state
+        st.session_state['current_fig'] = fig
+
+# Display the current figure, which remains unchanged until "Run" is clicked
+if 'current_fig' in st.session_state:
+    st.plotly_chart(st.session_state['current_fig'], use_container_width=True)
 
 hide_streamlit_style = """
 <style>