Update app.py

app.py

@@ -35,11 +35,9 @@ with st.sidebar.expander("How to Use:", expanded=False):
 # Function to fetch data
 @st.cache_data
 def get_data(ticker, start_date, end_date):
-    # Use auto_adjust=True to get adjusted price data (so "Close" is correct)
-    data = yf.download(ticker, start=start_date, end=end_date, auto_adjust=True)
-    # If a multi-index is returned (e.g. multiple tickers), drop the extra level
+    data = yf.download(ticker, start=start_date, end=end_date, auto_adjust=False)
     if isinstance(data.columns, pd.MultiIndex):
-        data.columns = data.columns.get_level_values(1)
+        data.columns = data.columns.get_level_values(0)
     if data.empty:
         raise ValueError(f"No data retrieved for {ticker}")
     if len(data) < 512:  # Ensure enough data for largest possible Rainbow MA period
@@ -136,80 +134,102 @@ def calculate_harmonic_moving_average(prices, period):
 # 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
 
-# Jurik Moving Average (JMA) and other MA functions remain unchanged...
-# (All other moving average functions are defined below exactly as before)
+    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]]
@@ -217,62 +237,81 @@ def calculate_EMA(prices, period):
         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)
+    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
+        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
 
+    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)
+    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:]:
@@ -280,42 +319,52 @@ def wilders_moving_average(prices, period):
         wilder.append(wilder_value)
     return wilder
 
+# Function to calculate Smoothed Moving Average (SMMA)
 def calculate_SMMA(prices, n):
-    SMMA = [np.nan] * (n-1)
+    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)
+        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]
+    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
+    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
 
+    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)):
@@ -326,6 +375,7 @@ def calculate_MedMA(prices, window):
             medians.append(median)
     return medians
 
+# Function to calculate Geometric Moving Average (GMA)
 def calculate_GMA(prices, window):
     gm_avg = []
     for i in range(len(prices)):
@@ -337,6 +387,7 @@ def calculate_GMA(prices, window):
             gm_avg.append(gma_value)
     return gm_avg
 
+# Function to calculate Elastic Volume Weighted Moving Average (eVWMA)
 def calculate_eVWMA(prices, volumes, window):
     evwma_values = []
     for i in range(len(prices)):
@@ -351,6 +402,7 @@ def calculate_eVWMA(prices, volumes, window):
             evwma_values.append(evwma)
     return evwma_values
 
+# Function to calculate McGinley Dynamic (MD)
 def calculate_mcginley_dynamic(prices, n):
     MD = [prices[0]]
     for i in range(1, len(prices)):
@@ -358,35 +410,47 @@ def calculate_mcginley_dynamic(prices, n):
         MD.append(md_value)
     return MD
 
+# 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 or Crypto Pair", 
     value=st.session_state.get('ticker_symbol', 'BTC-USD'),
     help="Enter the ticker symbol (e.g., AAPL for Apple) or Cryptocurrency Pair (e.g. BTC-USD)."
 )
 
+# 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")),
@@ -398,8 +462,10 @@ end_date = st.sidebar.date_input(
     help="Select the end date for fetching the stock data."
 )
 
+# Fetch Data button
 if st.sidebar.button('Fetch Data'):
     try:
+        # 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 
@@ -415,9 +481,11 @@ if st.sidebar.button('Fetch Data'):
     except Exception as e:
         st.error(f"An error occurred while fetching data: {e}")
 
+# 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
     with st.sidebar.expander("Simple Moving Average", expanded=False):
         use_sma = st.checkbox(
             'Simple Moving Average (SMA)', 
@@ -433,6 +501,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the SMA."
         )
     
+    # EMA with tooltip
     with st.sidebar.expander("Exponential Moving Average (EMA)", expanded=False):
         use_ema = st.checkbox(
             'Enable EMA', 
@@ -448,6 +517,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the EMA."
         )
     
+    # WMA with tooltip
     with st.sidebar.expander("Weighted Moving Average (WMA)", expanded=False):
         use_wma = st.checkbox(
             'Enable WMA', 
@@ -463,6 +533,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the WMA."
         )
     
+    # DEMA with tooltip
     with st.sidebar.expander("Double Exponential Moving Average (DEMA)", expanded=False):
         use_dema = st.checkbox(
             'Enable DEMA', 
@@ -478,6 +549,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the DEMA."
         )
     
+    # TEMA with tooltip
     with st.sidebar.expander("Triple Exponential Moving Average (TEMA)", expanded=False):
         use_tema = st.checkbox(
             'Enable TEMA', 
@@ -493,6 +565,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the TEMA."
         )
     
+    # VAMA with tooltip
     with st.sidebar.expander("Volume-Adjusted Moving Average (VAMA)", expanded=False):
         use_vama = st.checkbox(
             'Enable VAMA', 
@@ -508,6 +581,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the VAMA."
         )
     
+    # KAMA with tooltip
     with st.sidebar.expander("Kaufman Adaptive Moving Average (KAMA)", expanded=False):
         use_kama = st.checkbox(
             'Enable KAMA', 
@@ -539,6 +613,7 @@ if 'data' in st.session_state:
             help="Specify the slowest smoothing constant period."
         )
     
+    # TMA with tooltip
     with st.sidebar.expander("Triangular Moving Average (TMA)", expanded=False):
         use_tma = st.checkbox(
             'Enable TMA', 
@@ -553,7 +628,8 @@ if 'data' in st.session_state:
             disabled=not use_tma,
             help="Specify the period (in days) for the TMA."
         )
-    
+
+    # Hull MA with tooltip
     with st.sidebar.expander("Hull Moving Average (HMA)", expanded=False):
         use_hull_ma = st.checkbox(
             'Enable HMA', 
@@ -569,6 +645,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the Hull Moving Average."
         )
     
+    # Harmonic MA with tooltip
     with st.sidebar.expander("Harmonic Moving Average (HMA)", expanded=False):
         use_harmonic_ma = st.checkbox(
             'Enable HMA', 
@@ -584,6 +661,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the Harmonic Moving Average."
         )
     
+    # FRAMA with tooltip
     with st.sidebar.expander("Fractal Adaptive Moving Average (FRAMA)", expanded=False):
         use_frama = st.checkbox(
             'Enable FRAMA', 
@@ -599,6 +677,7 @@ if 'data' in st.session_state:
             help="Specify the batch size for FRAMA calculation."
         )
     
+    # ZLEMA with tooltip
     with st.sidebar.expander("Zero Lag Exponential Moving Average (ZLEMA)", expanded=False):
         use_zlema = st.checkbox(
             'Enable ZLEMA', 
@@ -614,6 +693,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the ZLEMA."
         )
     
+    # VIDYA with tooltip
     with st.sidebar.expander("Variable Index Dynamic Average (VIDYA)", expanded=False):
         use_vidya = st.checkbox(
             'Enable VIDYA', 
@@ -629,6 +709,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the VIDYA."
         )
     
+    # ALMA with tooltip
     with st.sidebar.expander("Arnaud Legoux Moving Average (ALMA)", expanded=False):
         use_alma = st.checkbox(
             'Enable ALMA', 
@@ -661,6 +742,7 @@ if 'data' in st.session_state:
             help="Specify the sigma for the ALMA."
         )
     
+    # MAMA and FAMA with tooltip
     with st.sidebar.expander("MESA Adaptive Moving Average (MAMA) & FAMA", expanded=False):
         use_mama_fama = st.checkbox(
             'Enable MAMA & FAMA', 
@@ -686,6 +768,7 @@ if 'data' in st.session_state:
             help="Specify the slow limit for MAMA (0 to 1)."
         )
 
+    # APMA with tooltip
     with st.sidebar.expander("Adaptive Period Moving Average (APMA)", expanded=False):
         use_apma = st.checkbox(
             'Enable APMA', 
@@ -709,6 +792,7 @@ if 'data' in st.session_state:
             help="Specify the maximum period for the APMA."
         )
     
+    # Rainbow EMA with tooltip
     with st.sidebar.expander("Rainbow Moving Average (EMA)", expanded=False):
         use_rainbow_ema = st.checkbox(
             'Enable Rainbow EMA', 
@@ -723,6 +807,7 @@ if 'data' in st.session_state:
             help="Select multiple lookback periods for the Rainbow EMA."
         )
     
+    # Wilders MA with tooltip
     with st.sidebar.expander("Wilders Moving Average (Wilder's MA)", expanded=False):
         use_wilders_ma = st.checkbox(
             'Enable Wilders MA', 
@@ -738,6 +823,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for Wilder's Moving Average."
         )
     
+    # SMMA with tooltip
     with st.sidebar.expander("Smoothed Moving Average (SMMA)", expanded=False):
         use_smma = st.checkbox(
             'Enable SMMA', 
@@ -753,6 +839,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the SMMA."
         )
     
+    # GMMA with tooltip
     with st.sidebar.expander("Guppy Multiple Moving Average (GMMA)", expanded=False):
         use_gmma = st.checkbox(
             'Enable GMMA', 
@@ -774,6 +861,7 @@ if 'data' in st.session_state:
             help="Select the long-term periods for GMMA."
         )
     
+    # LSMA with tooltip
     with st.sidebar.expander("Least Squares Moving Average (LSMA)", expanded=False):
         use_lsma = st.checkbox(
             'Enable LSMA', 
@@ -789,6 +877,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the LSMA."
         )
     
+    # MMA (Welch's MMA) with tooltip
     with st.sidebar.expander("Welch's Moving Average (MMA)", expanded=False):
         use_mma = st.checkbox(
             'Enable MMA', 
@@ -804,6 +893,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the MMA."
         )
     
+    # SinWMA with tooltip
     with st.sidebar.expander("Sin-weighted Moving Average (SinWMA)", expanded=False):
         use_sinwma = st.checkbox(
             'Enable SinWMA', 
@@ -819,6 +909,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the SinWMA."
         )
     
+    # MedMA with tooltip
     with st.sidebar.expander("Median Moving Average (MedMA)", expanded=False):
         use_medma = st.checkbox(
             'Enable MedMA', 
@@ -834,6 +925,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the MedMA."
         )
     
+    # GMA with tooltip
     with st.sidebar.expander("Geometric Moving Average (GMA)", expanded=False):
         use_gma = st.checkbox(
             'Enable GMA', 
@@ -849,6 +941,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the GMA."
         )
     
+    # eVWMA with tooltip
     with st.sidebar.expander("Elastic Volume Weighted Moving Average (eVWMA)", expanded=False):
         use_evwma = st.checkbox(
             'Enable eVWMA', 
@@ -863,7 +956,8 @@ if 'data' in st.session_state:
             disabled=not use_evwma,
             help="Specify the period (in days) for the eVWMA."
         )
-    
+
+    # REMA with tooltip
     with st.sidebar.expander("Regularized Exponential Moving Average (REMA)", expanded=False):
         use_rema = st.checkbox(
             'Enable REMA', 
@@ -889,6 +983,7 @@ if 'data' in st.session_state:
             help="Specify the lambda value for the REMA (0 to 1)."
         )
     
+    # PWMA with tooltip
     with st.sidebar.expander("Parabolic Weighted Moving Average (PWMA)", expanded=False):
         use_pwma = st.checkbox(
             'Enable PWMA', 
@@ -904,6 +999,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the PWMA."
         )
     
+    # JMA with tooltip
     with st.sidebar.expander("Jurik Moving Average (JMA)", expanded=False):
         use_jma = st.checkbox(
             'Enable JMA', 
@@ -928,6 +1024,7 @@ if 'data' in st.session_state:
             help="Specify the phase for the JMA (-100 to 100)."
         )
     
+    # EPMA with tooltip
     with st.sidebar.expander("End Point Moving Average (EPMA)", expanded=False):
         use_epma = st.checkbox(
             'Enable EPMA', 
@@ -943,14 +1040,16 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the EPMA."
         )
     
+    # CMA with tooltip
     with st.sidebar.expander("Chande Moving Average (CMA)", expanded=False):
         use_cma = st.checkbox(
             'Enable 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'])  # Automatically use full length
+        cma_period = len(data['Close'])  # This does not require user input.
     
+    # McGinley Dynamic with tooltip
     with st.sidebar.expander("McGinley Dynamic", expanded=False):
         use_mcginley_dynamic = st.checkbox(
             'Enable McGinley Dynamic', 
@@ -966,6 +1065,7 @@ if 'data' in st.session_state:
             help="Specify the period (in days) for the McGinley Dynamic."
         )
 
+    # Filtered Moving Average (FMA) with tooltip
     with st.sidebar.expander("Filtered Moving Average (FMA)", expanded=False):
         use_fma = st.checkbox(
             'Enable FMA', 
@@ -981,263 +1081,306 @@ if 'data' in st.session_state:
             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."
     )
     
+    # Run button to apply moving averages
     if st.sidebar.button('Run Analysis'):
-        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_fma'] = use_fma
-        st.session_state['fma_period'] = fma_period
-        
-        fig = go.Figure(data=st.session_state['price_plot'].data)
-        
-        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')))
-        
-        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')))
-
-        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')))
-
-        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')))
-
-        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')))
-
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
+        try:
+            # 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_fma'] = use_fma
+            st.session_state['fma_period'] = fma_period
+            
+            # 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 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)
+            )
         
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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)])))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-        
-        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')))
-
-        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)
-        )
-    
-        st.session_state['current_fig'] = fig
+            # Store the updated figure in session state
+            st.session_state['current_fig'] = fig
+        except Exception as e:
+            st.error(f"An error occurred while running analysis: {e}")
 
+# 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)
 
@@ -1246,7 +1389,7 @@ st.markdown(
     <style>
     /* Adjust the width of the sidebar */
     [data-testid="stSidebar"] {
-        width: 500px;
+        width: 500px;  /* Change this value to set the width you want */
     }
     </style>
     """,
@@ -1259,4 +1402,4 @@ hide_streamlit_style = """
 footer {visibility: hidden;}
 </style>
 """
-st.markdown(hide_streamlit_style, unsafe_allow_html=True)
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)