Update app.py

app.py

@@ -35,9 +35,11 @@ with st.sidebar.expander("How to Use:", expanded=False):
 # 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, auto_adjust=False)
+    # 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
     if isinstance(data.columns, pd.MultiIndex):
-        data.columns = data.columns.get_level_values(0)
+        data.columns = data.columns.get_level_values(1)
     if data.empty:
         raise ValueError(f"No data retrieved for {ticker}")
     if len(data) < 512:  # Ensure enough data for largest possible Rainbow MA period
@@ -134,102 +136,80 @@ 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
 
-# Chande Moving Average (CMA) Function
+# Jurik Moving Average (JMA) and other MA functions remain unchanged...
+# (All other moving average functions are defined below exactly as before)
+
 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]]
@@ -237,81 +217,62 @@ 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)  # Add a zero at the beginning for alignment
+    return np.insert(cmo, 0, 0)
 
-# 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]
+        alpha = abs(cmo_values[i]) / 100
         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)  # Initialize with NaN values
-
+    moving_averages = np.full_like(prices, np.nan)
     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:]:
@@ -319,52 +280,42 @@ 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)  # Fill the initial n-1 values with NaN
+    SMMA = [np.nan] * (n-1)
     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.append(m * n + c)
     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
+    MMA = [sum(prices[:period]) / period]
     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
+    return [None]*(period-1) + MMA
 
-# 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)):
@@ -375,7 +326,6 @@ 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)):
@@ -387,7 +337,6 @@ 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)):
@@ -402,7 +351,6 @@ 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)):
@@ -410,47 +358,35 @@ 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")),
@@ -462,10 +398,8 @@ 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 
@@ -481,19 +415,15 @@ 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
-    # SMA with tooltip
     with st.sidebar.expander("Simple Moving Average", expanded=False):
         use_sma = st.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.number_input(
             'SMA Period', 
             min_value=1, 
@@ -503,7 +433,6 @@ 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', 
@@ -519,7 +448,6 @@ 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', 
@@ -535,7 +463,6 @@ 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', 
@@ -551,7 +478,6 @@ 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', 
@@ -567,7 +493,6 @@ 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', 
@@ -583,7 +508,6 @@ 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', 
@@ -615,7 +539,6 @@ 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', 
@@ -630,8 +553,7 @@ 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', 
@@ -647,7 +569,6 @@ 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', 
@@ -663,7 +584,6 @@ 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', 
@@ -679,7 +599,6 @@ 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', 
@@ -695,7 +614,6 @@ 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', 
@@ -711,7 +629,6 @@ 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', 
@@ -744,7 +661,6 @@ 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', 
@@ -770,7 +686,6 @@ 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', 
@@ -794,7 +709,6 @@ 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', 
@@ -809,7 +723,6 @@ 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', 
@@ -825,7 +738,6 @@ 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', 
@@ -841,7 +753,6 @@ 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', 
@@ -863,7 +774,6 @@ 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', 
@@ -879,7 +789,6 @@ 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', 
@@ -895,7 +804,6 @@ 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', 
@@ -911,7 +819,6 @@ 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', 
@@ -927,7 +834,6 @@ 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', 
@@ -943,7 +849,6 @@ 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', 
@@ -958,8 +863,7 @@ 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', 
@@ -985,7 +889,6 @@ 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', 
@@ -1001,7 +904,6 @@ 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', 
@@ -1026,7 +928,6 @@ 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', 
@@ -1042,16 +943,14 @@ 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'])  # This does not require user input.
+        cma_period = len(data['Close'])  # Automatically use full length
     
-    # McGinley Dynamic with tooltip
     with st.sidebar.expander("McGinley Dynamic", expanded=False):
         use_mcginley_dynamic = st.checkbox(
             'Enable McGinley Dynamic', 
@@ -1067,7 +966,6 @@ 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', 
@@ -1083,16 +981,13 @@ 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'):
-        # 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
@@ -1168,58 +1063,47 @@ if 'data' in st.session_state:
         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()
@@ -1227,13 +1111,11 @@ if 'data' in st.session_state:
             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)
@@ -1246,75 +1128,62 @@ if 'data' in st.session_state:
                 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:
@@ -1323,49 +1192,40 @@ if 'data' in st.session_state:
             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',
@@ -1376,10 +1236,8 @@ if 'data' in st.session_state:
             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)
 
@@ -1388,7 +1246,7 @@ st.markdown(
     <style>
     /* Adjust the width of the sidebar */
     [data-testid="stSidebar"] {
-        width: 500px;  /* Change this value to set the width you want */
+        width: 500px;
     }
     </style>
     """,
@@ -1401,4 +1259,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)