Upload app.py

app.py

@@ -10,7 +10,8 @@ import json
 # --- CORRECTED IMPORTS: Moved MACD ---
 from ta.volatility import BollingerBands
 from ta.momentum import RSIIndicator # Removed MACD from here
-from ta.trend import ADXIndicator, MACD # Added MACD here
+from ta.trend import ADXIndicator, MACD 
+from ta.volume import MFIIndicator # Added MFI here
 # --- [NEW] ADDED ATR FOR INTELLIGENT EXIT ---
 from ta.volatility import AverageTrueRange
 # --- [END NEW] ---
@@ -473,10 +474,12 @@ def clean_data_and_report_outliers(df):
 
 # --- 2. Custom Backtesting Engine ---
 
-# --- [NEW] 7-Factor Version (with Markov State and RAW GRADIENT scoring) ---
-def calculate_confidence_score(df, primary_driver, # <-- This exists
-                                use_rsi, use_volatility, use_trend, use_volume, use_macd, use_ma_slope, use_markov, # 7 toggles
-                                rsi_w, vol_w, trend_w, vol_w_val, macd_w, ma_slope_w, markov_w, # 7 weights
+# --- [UPDATED] 9-Factor Version (with MFI & SuperTrend) ---
+def calculate_confidence_score(df, primary_driver,
+                                use_rsi, use_volatility, use_trend, use_volume, use_macd, use_ma_slope, use_markov, 
+                                use_mfi, use_supertrend, 
+                                rsi_w, vol_w, trend_w, vol_w_val, macd_w, ma_slope_w, markov_w, 
+                                mfi_w, supertrend_w, 
                                 bband_params,
                                 best_markov_setup=None):
 
@@ -489,92 +492,83 @@ def calculate_confidence_score(df, primary_driver, # <-- This exists
         df['RunUp_Return'] = df['Close'].pct_change(periods=run_up_period)
         df['RunUp_State'] = df['RunUp_Return'].apply(lambda x: 'Up' if x > 0 else 'Down')
 
-    # --- BBand Factor (Still uses gradient logic as it's a "how far" metric) ---
+    # --- BBand Factor ---
     if primary_driver != 'Bollinger Bands' and 'bband_lower' in df.columns:
-        bb_weight = 1.0 # This factor has a fixed weight of 1.0
+        bb_weight = 1.0 
         long_entry_pct = bband_params.get('long_entry_threshold_pct', 0.0)
         short_entry_pct = bband_params.get('short_entry_threshold_pct', 0.0)
         long_bb_trigger_price = df['bband_lower'] * (1 - long_entry_pct)
         short_bb_trigger_price = df['bband_upper'] * (1 + short_entry_pct)
         long_score_range = (df['large_ma'] - long_bb_trigger_price).replace(0, np.nan)
         short_score_range = (short_bb_trigger_price - df['large_ma']).replace(0, np.nan)
-        long_score_pct = ((df['large_ma'] - df['Close']) / long_score_range).clip(0, 1).fillna(0)
-        short_score_pct = ((df['Close'] - df['large_ma']) / short_score_range).clip(0, 1).fillna(0)
-        long_score += long_score_pct * bb_weight
-        short_score += short_score_pct * bb_weight
-
-    # --- [RESTORED] Gradient Factor Scoring ---
+        long_score += ((df['large_ma'] - df['Close']) / long_score_range).clip(0, 1).fillna(0) * bb_weight
+        short_score += ((df['Close'] - df['large_ma']) / short_score_range).clip(0, 1).fillna(0) * bb_weight
 
     # Factor 1: RSI
-    if primary_driver != 'RSI Crossover' and use_rsi and 'RSI' in df.columns and not df['RSI'].isna().all():
+    if primary_driver != 'RSI Crossover' and use_rsi and 'RSI' in df.columns:
         long_score += ((30 - df['RSI']) / 30).clip(0, 1).fillna(0) * rsi_w
         short_score += ((df['RSI'] - 70) / 30).clip(0, 1).fillna(0) * rsi_w
 
     # Factor 2: Volatility
-    if use_volatility and 'Volatility_p' in df.columns and not df['Volatility_p'].isna().all():
-        # This one is binary
+    if use_volatility and 'Volatility_p' in df.columns:
         vol_signal = (df['Volatility_p'] > 0.025).astype(float) * vol_w
-        long_score += vol_signal
-        short_score += vol_signal
+        long_score += vol_signal; short_score += vol_signal
 
-    # Factor 3: Trend (Distance from SMA200)
-    if use_trend and 'SMA_200' in df.columns and 'Close' in df.columns \
-            and not df['SMA_200'].isna().all() and not df['Close'].isna().all():
-        valid_sma = (df['SMA_200'] != 0) & df['SMA_200'].notna() & df['Close'].notna()
+    # Factor 3: Trend
+    if use_trend and 'SMA_200' in df.columns and 'Close' in df.columns:
+        valid_sma = (df['SMA_200'] != 0) & df['SMA_200'].notna()
         pct_dist = pd.Series(0.0, index=df.index)
         pct_dist.loc[valid_sma] = df.loc[valid_sma].apply(lambda row: (row['Close'] - row['SMA_200']) / row['SMA_200'] if row['SMA_200'] != 0 else 0, axis=1)
         long_score += (pct_dist / 0.10).clip(0, 1).fillna(0) * trend_w
         short_score += (-pct_dist / 0.10).clip(0, 1).fillna(0) * trend_w
 
     # Factor 4: Volume
-    if use_volume and 'Volume_Ratio' in df.columns and not df['Volume_Ratio'].isna().all():
-        # This one is a gradient
+    if use_volume and 'Volume_Ratio' in df.columns:
         vol_spike_signal = ((df['Volume_Ratio'] - 1.75) / 2.25).clip(0, 1).fillna(0) * vol_w_val
-        long_score += vol_spike_signal
-        short_score += vol_spike_signal
+        long_score += vol_spike_signal; short_score += vol_spike_signal
 
-    # Factor 5: MACD Signals
-    if primary_driver != 'MACD Crossover' and use_macd and 'MACD_line' in df.columns and 'MACD_signal' in df.columns and 'MACD_hist' in df.columns \
-            and not df['MACD_line'].isna().all() and not df['MACD_signal'].isna().all() and not df['MACD_hist'].isna().all():
-        # This is a hybrid gradient/binary
+    # Factor 5: MACD
+    if primary_driver != 'MACD Crossover' and use_macd and 'MACD_line' in df.columns:
         macd_cross_long = (df['MACD_line'].shift(1) < df['MACD_signal'].shift(1)) & (df['MACD_line'] >= df['MACD_signal'])
         macd_cross_short = (df['MACD_line'].shift(1) > df['MACD_signal'].shift(1)) & (df['MACD_line'] <= df['MACD_signal'])
         long_score += macd_cross_long.astype(float) * macd_w * 0.6
         short_score += macd_cross_short.astype(float) * macd_w * 0.6
-        hist_positive = df['MACD_hist'] > 0
-        hist_negative = df['MACD_hist'] < 0
-        long_score += hist_positive.astype(float) * macd_w * 0.4
-        short_score += hist_negative.astype(float) * macd_w * 0.4
+        long_score += (df['MACD_hist'] > 0).astype(float) * macd_w * 0.4
+        short_score += (df['MACD_hist'] < 0).astype(float) * macd_w * 0.4
 
     # Factor 6: MA Slope
-    if primary_driver != 'MA Slope' and use_ma_slope and 'ma_slope' in df.columns and not df['ma_slope'].isna().all():
-        # This is binary
+    if primary_driver != 'MA Slope' and use_ma_slope and 'ma_slope' in df.columns:
         long_score += (df['ma_slope'] > 0).astype(float) * ma_slope_w
         short_score += (df['ma_slope'] < 0).astype(float) * ma_slope_w
 
     # Factor 7: Markov State
     if primary_driver != 'Markov State' and use_markov and best_markov_setup and 'RunUp_State' in df.columns:
         strategy = best_markov_setup.get('Strategy')
-        if strategy == 'Down -> Up':
-            long_score += (df['RunUp_State'] == 'Down').astype(float) * markov_w
-        elif strategy == 'Up -> Up':
-            long_score += (df['RunUp_State'] == 'Up').astype(float) * markov_w
-        elif strategy == 'Up -> Down':
-            short_score += (df['RunUp_State'] == 'Up').astype(float) * markov_w
-        elif strategy == 'Down -> Down':
-            short_score += (df['RunUp_State'] == 'Down').astype(float) * markov_w
-    # --- [END] ---
+        if strategy == 'Down -> Up': long_score += (df['RunUp_State'] == 'Down').astype(float) * markov_w
+        elif strategy == 'Up -> Up': long_score += (df['RunUp_State'] == 'Up').astype(float) * markov_w
+        elif strategy == 'Up -> Down': short_score += (df['RunUp_State'] == 'Up').astype(float) * markov_w
+        elif strategy == 'Down -> Down': short_score += (df['RunUp_State'] == 'Down').astype(float) * markov_w
+
+    # Factor 8: MFI (Money Flow Index) [IMPROVED]
+    if use_mfi and 'MFI' in df.columns:
+        # Binary Logic: If MFI < 20 (Oversold), give full weight. 
+        # This fixes the "tiny score" issue.
+        long_score += (df['MFI'] < 25).astype(float) * mfi_w
+        short_score += (df['MFI'] > 75).astype(float) * mfi_w
+
+    # Factor 9: SuperTrend [IMPROVED]
+    if use_supertrend and 'SuperTrend' in df.columns:
+        # Long Score: Price > SuperTrend (Trend is Bullish)
+        long_score += (df['Close'] > df['SuperTrend']).astype(float) * supertrend_w
+        # Short Score: Price < SuperTrend (Trend is Bearish)
+        short_score += (df['Close'] < df['SuperTrend']).astype(float) * supertrend_w
 
-    # --- [REMOVED NORMALIZATION] ---
-    # Return the raw, un-normalized scores
     return long_score.fillna(0), short_score.fillna(0)
 
-# --- FINAL VERSION: Merged Intelligent Exit + All Missing Features ---
-
 # --- FULL REPLACEMENT FOR run_backtest FUNCTION ---
 def run_backtest(data, params,
-                 use_rsi, use_volatility, use_trend, use_volume, use_macd, use_ma_slope, use_markov, 
-                 rsi_w, vol_w, trend_w, vol_w_val, macd_w, ma_slope_w, markov_w, 
+                 use_rsi, use_volatility, use_trend, use_volume, use_macd, use_ma_slope, use_markov, use_mfi, use_supertrend, # Added MFI/ST
+                 rsi_w, vol_w, trend_w, vol_w_val, macd_w, ma_slope_w, markov_w, mfi_w, supertrend_w, # Added MFI/ST weights
                  use_adx_filter, adx_threshold, rsi_logic, 
                  adx_period=14, 
                  veto_setups_list=None,
@@ -643,6 +637,78 @@ def run_backtest(data, params,
     else: 
         df['RSI'], df['Volatility_p'], df['ADX'], df['ATR'] = np.nan, np.nan, np.nan, np.nan
 
+# --- [NEW] MFI & SUPERTREND CALCULATIONS (Fixed) ---
+    if len(df) >= 14:
+        # 1. MFI Calculation
+        try:
+            mfi_ind = MFIIndicator(high=df['High'], low=df['Low'], close=df['Close'], volume=df['Volume'], window=14, fillna=True)
+            df['MFI'] = mfi_ind.money_flow_index()
+        except Exception: df['MFI'] = 50.0 
+
+        # 2. Proper Recursive SuperTrend Calculation
+        try:
+            st_period = 10
+            st_multiplier = 3.0
+            
+            # Calculate ATR
+            high_low = df['High'] - df['Low']
+            high_close = np.abs(df['High'] - df['Close'].shift())
+            low_close = np.abs(df['Low'] - df['Close'].shift())
+            ranges = pd.concat([high_low, high_close, low_close], axis=1)
+            true_range = np.max(ranges, axis=1)
+            atr = true_range.rolling(st_period).mean().fillna(0)
+
+            # Basic Bands
+            hl2 = (df['High'] + df['Low']) / 2
+            basic_upper = hl2 + (st_multiplier * atr)
+            basic_lower = hl2 - (st_multiplier * atr)
+
+            # Initialize Final Bands
+            final_upper = basic_upper.copy()
+            final_lower = basic_lower.copy()
+            trend = np.zeros(len(df), dtype=int)
+            supertrend = np.zeros(len(df))
+            
+            # Recursive Loop (Accurate Logic)
+            close = df['Close'].values
+            bu = basic_upper.values
+            bl = basic_lower.values
+            fu = final_upper.values
+            fl = final_lower.values
+            
+            # 1 = Uptrend, -1 = Downtrend
+            curr_trend = 1 
+            
+            for i in range(1, len(df)):
+                # Calculate Final Upper Band
+                if bu[i] < fu[i-1] or close[i-1] > fu[i-1]:
+                    fu[i] = bu[i]
+                else:
+                    fu[i] = fu[i-1]
+                
+                # Calculate Final Lower Band
+                if bl[i] > fl[i-1] or close[i-1] < fl[i-1]:
+                    fl[i] = bl[i]
+                else:
+                    fl[i] = fl[i-1]
+                
+                # Determine Trend
+                if curr_trend == 1 and close[i] < fl[i]:
+                    curr_trend = -1
+                elif curr_trend == -1 and close[i] > fu[i]:
+                    curr_trend = 1
+                
+                trend[i] = curr_trend
+                supertrend[i] = fl[i] if curr_trend == 1 else fu[i]
+
+            df['SuperTrend'] = supertrend
+            
+        except Exception as e: 
+            # print(f"ST Error: {e}") # Debug if needed
+            df['SuperTrend'] = np.nan
+    else:
+        df['MFI'], df['SuperTrend'] = 50.0, np.nan
+
     df['SMA_200'] = df['Close'].rolling(window=200, min_periods=1).mean()
 
     if 'Volume' in df.columns:
@@ -672,7 +738,9 @@ def run_backtest(data, params,
     raw_long_score, raw_short_score = calculate_confidence_score(df,
         primary_driver,
         use_rsi, use_volatility, use_trend, use_volume, use_macd, use_ma_slope, use_markov, 
+        use_mfi, use_supertrend, # <--- NEW
         rsi_w, vol_w, trend_w, vol_w_val, macd_w, ma_slope_w, markov_w, 
+        mfi_w, supertrend_w, # <--- NEW
         bband_params_for_score,
         best_markov_setup=markov_setup 
     )
@@ -759,7 +827,11 @@ def run_backtest(data, params,
     
     # [SURGICAL PATCH START] --------------------------------------------------
     # Check if ALL confidence indicators are disabled
-    all_indicators_off = not any([use_rsi, use_volatility, use_trend, use_volume, use_macd, use_ma_slope, use_markov])
+    # CORRECTED: Added use_mfi and use_supertrend to this list so the score isn't ignored when they are On.
+    all_indicators_off = not any([
+        use_rsi, use_volatility, use_trend, use_volume, use_macd, use_ma_slope, use_markov,
+        use_mfi, use_supertrend 
+    ])
 
     # If indicators are OFF, we bypass the confidence check (allow raw signal)
     # Otherwise, we enforce the confidence threshold as usual
@@ -1019,18 +1091,34 @@ def generate_long_plot(df, trades, ticker):
         fig.add_trace(go.Scatter(x=df.index, y=df['bband_upper'], mode='lines', name='Upper Band', line=dict(color='gray', width=0.5)))
         fig.add_trace(go.Scatter(x=df.index, y=df['bband_lower'], mode='lines', name='Lower Band', line=dict(color='gray', width=0.5), fill='tonexty', fillcolor='rgba(211,211,211,0.2)'))
 
-    # Add Trades
+    # Unpack Trades Tuple: (Long Entries Log, Long Exits Index, Short Entries Log, Short Exits Index)
     long_entries_log, long_exits, _, _ = trades
+    
+    # 1. Plot Long Entries
     if long_entries_log:
         dates = [t['date'] for t in long_entries_log]
         prices = [t['price'] for t in long_entries_log]
         scores = [f"Confidence: {t['confidence']:.0f}%" for t in long_entries_log]
-        fig.add_trace(go.Scatter(x=dates, y=prices, mode='markers', name='Long Entry', marker=dict(color='green', symbol='triangle-up', size=12), text=scores, hoverinfo='text'))
-    if not long_exits.empty and 'Close' in df.columns: # Check if Close exists
-        exit_prices = df.loc[long_exits,'Close'].dropna() # Drop exits where price might be NaN
-        fig.add_trace(go.Scatter(x=exit_prices.index, y=exit_prices, mode='markers', name='Long Exit', marker=dict(color='darkgreen', symbol='x', size=8)))
-
-    fig.update_layout(title=f'Long Trades for {ticker}', xaxis_title='Date', yaxis_title='Price', legend_title="Indicator"); return fig
+        
+        # Filter out entries that fall outside the dataframe's date range (just in case)
+        valid_points = [(d, p, s) for d, p, s in zip(dates, prices, scores) if d in df.index]
+        if valid_points:
+            v_dates, v_prices, v_scores = zip(*valid_points)
+            fig.add_trace(go.Scatter(x=v_dates, y=v_prices, mode='markers', name='Long Entry', 
+                                     marker=dict(color='green', symbol='triangle-up', size=12), 
+                                     text=v_scores, hoverinfo='text'))
+
+    # 2. Plot Long Exits
+    # Ensure long_exits is not empty and contains valid dates found in df
+    if not long_exits.empty:
+        valid_exits = [date for date in long_exits if date in df.index]
+        if valid_exits:
+            exit_prices = df.loc[valid_exits, 'Close']
+            fig.add_trace(go.Scatter(x=exit_prices.index, y=exit_prices, mode='markers', name='Long Exit', 
+                                     marker=dict(color='darkgreen', symbol='x', size=8)))
+
+    fig.update_layout(title=f'Long Trades for {ticker}', xaxis_title='Date', yaxis_title='Price', legend_title="Indicator")
+    return fig
 
 def generate_short_plot(df, trades, ticker):
     fig = go.Figure()
@@ -3269,11 +3357,14 @@ def main():
     for key, val in defaults.items():
         if key not in st.session_state: st.session_state[key] = val
         
-    # 4. Helper to update state from widgets
+    # 4. Helper to update state from widgets (Fixed)
     def update_state():
-        for key in defaults.keys():
-            widget_key = f"widget_{key}"
-            if widget_key in st.session_state: st.session_state[key] = st.session_state[widget_key]
+        keys = list(st.session_state.keys())
+        for widget_key in keys:
+            if widget_key.startswith('widget_'):
+                main_key = widget_key[len('widget_'):]
+                if main_key in st.session_state:
+                    st.session_state[main_key] = st.session_state[widget_key]
     
     st.set_page_config(page_title="Dave's Quant System", page_icon="🔴", layout="wide")
 
@@ -3470,13 +3561,20 @@ def main():
     st.sidebar.radio("Mode:", ("Analyse Single Ticker", full_list_label), key='run_mode')
 
     if st.session_state.get('run_mode') == "Analyse Single Ticker":
-        if not ticker_list: 
-            st.sidebar.warning("No tickers loaded.")
-        else:
-            ticker_index = 0 
-            try: ticker_index = ticker_list.index(st.session_state.ticker_select)
-            except ValueError: ticker_index = 0
-            st.sidebar.selectbox("Select a Ticker:", ticker_list, index=ticker_index, key='widget_ticker_select', on_change=update_state)
+            if not ticker_list:
+                st.sidebar.warning("No tickers loaded.")
+            else:
+                # Ensure valid selection logic (only reset if invalid/None)
+                if st.session_state.ticker_select not in ticker_list:
+                    st.session_state.ticker_select = ticker_list[0]
+
+                try:
+                    ticker_index = ticker_list.index(st.session_state.ticker_select)
+                except ValueError:
+                    ticker_index = 0
+                
+                # [FIXED] Removed the unconditional reset line that was here
+                st.sidebar.selectbox("Select a Ticker:", ticker_list, index=ticker_index, key='widget_ticker_select', on_change=update_state )
 
     # --- UPDATED: Date Inputs (Fully Unrestricted 2000-2030) ---
     st.sidebar.date_input(
@@ -3813,9 +3911,22 @@ def main():
         if 'widget_markov_w' not in st.session_state: st.session_state.widget_markov_w = st.session_state.markov_w
         st.sidebar.number_input("Markov Weight", 0.1, 5.0, step=0.1, key='widget_markov_w', on_change=update_state, disabled=not st.session_state.get('use_markov', True))
         
+        # --- NEW: MFI Controls ---
+        if 'widget_use_mfi' not in st.session_state: st.session_state.widget_use_mfi = st.session_state.use_mfi
+        st.sidebar.toggle("Use Money Flow (MFI)", key='widget_use_mfi', on_change=update_state)
+        
+        if 'widget_mfi_w' not in st.session_state: st.session_state.widget_mfi_w = st.session_state.mfi_w
+        st.sidebar.number_input("MFI Weight", 0.1, 5.0, step=0.1, key='widget_mfi_w', on_change=update_state, disabled=not st.session_state.get('use_mfi', True))
+
+        # --- NEW: SuperTrend Controls ---
+        if 'widget_use_supertrend' not in st.session_state: st.session_state.widget_use_supertrend = st.session_state.use_supertrend
+        st.sidebar.toggle("Use SuperTrend", key='widget_use_supertrend', on_change=update_state)
+
+        if 'widget_supertrend_w' not in st.session_state: st.session_state.widget_supertrend_w = st.session_state.supertrend_w
+        st.sidebar.number_input("SuperTrend Weight", 0.1, 5.0, step=0.1, key='widget_supertrend_w', on_change=update_state, disabled=not st.session_state.get('use_supertrend', True))
+
         if 'widget_confidence_slider' not in st.session_state: st.session_state.widget_confidence_slider = st.session_state.confidence_slider
         st.sidebar.slider("Minimum Confidence Threshold (%)", 0, 100, step=5, key='widget_confidence_slider', on_change=update_state)
-
     st.sidebar.markdown("---")
 
     st.sidebar.header("3. Strategy Parameters")
@@ -4243,38 +4354,61 @@ def main():
 
                 # A) Single Ticker Analysis
                 if st.session_state.run_mode == "Analyse Single Ticker":
+                    # --- [FIX START] Logic integrated from old_but_working_app.py ---
                     selected_ticker = st.session_state.get('ticker_select', ticker_list[0] if ticker_list else None)
-                    if not selected_ticker: st.error("No ticker selected."); st.stop()
-                    
+                    if not selected_ticker:
+                        st.error("No ticker selected.")
+                        st.stop()
+            
+                    user_start_date = pd.Timestamp(st.session_state.start_date)
+
                     cols_to_use = [selected_ticker]
                     if f'{selected_ticker}_High' in master_df.columns: cols_to_use.append(f'{selected_ticker}_High')
                     if f'{selected_ticker}_Low' in master_df.columns: cols_to_use.append(f'{selected_ticker}_Low')
                     if f'{selected_ticker}_Volume' in master_df.columns: cols_to_use.append(f'{selected_ticker}_Volume')
+
                     existing_cols = [col for col in cols_to_use if col in master_df.columns]
-                    
-                    # Load data with WARMUP
-                    data_for_backtest_full = master_df.loc[:, existing_cols]
-                    data_for_backtest = data_for_backtest_full.loc[data_load_start:end_date]
-                    
+                    if selected_ticker not in existing_cols:
+                        st.error(f"Ticker '{selected_ticker}' not found.")
+                        st.stop()
+
+                    # We use the full dataframe here (without date slicing) to allow run_backtest to handle warm-up
+                    data_for_backtest = master_df.loc[:, existing_cols].copy()
+            
                     rename_dict = {selected_ticker: 'Close', f'{selected_ticker}_High': 'High', f'{selected_ticker}_Low': 'Low', f'{selected_ticker}_Volume': 'Volume'}
                     rename_dict_filtered = {k: v for k, v in rename_dict.items() if k in existing_cols}
                     data_for_backtest = data_for_backtest.rename(columns=rename_dict_filtered)
-                    
+
                     if not data_for_backtest.empty and 'Close' in data_for_backtest.columns and not data_for_backtest['Close'].isna().all():
+                        # --- [FIX END] ---
+
+                         # --- CORRECTED CALL (Matches Analyse Full List) ---
                          long_pnl, short_pnl, avg_long_trade, avg_short_trade, results_df, trades, open_trades, trade_counts, durations, trade_dates, exit_breakdown = run_backtest(
-                            data_for_backtest, manual_params,
-                            st.session_state.use_rsi, st.session_state.use_vol, st.session_state.use_trend, st.session_state.use_volume,
-                            st.session_state.use_macd, st.session_state.use_ma_slope, st.session_state.use_markov,
-                            st.session_state.rsi_w, st.session_state.vol_w, st.session_state.trend_w, st.session_state.volume_w,
-                            st.session_state.macd_w, st.session_state.ma_slope_w, st.session_state.markov_w,
-                            st.session_state.use_adx_filter, st.session_state.adx_threshold,
-                            st.session_state.get('rsi_logic', 'Crossover'), st.session_state.adx_period, 
-                            veto_setups_list=veto_list_to_use, primary_driver=st.session_state.primary_driver,
-                            markov_setup=markov_setup_to_use, exit_logic_type=exit_logic, exit_confidence_threshold=exit_thresh,
-                            smart_trailing_stop_pct=smart_trailing_stop, smart_exit_atr_period=smart_atr_p,
-                            smart_exit_atr_multiplier=smart_atr_m, intelligent_tsl_pct=intelligent_tsl,
-                            analysis_start_date=user_start_date # <--- Pass the filter date
-                        )
+                         data_for_backtest, manual_params,
+                         # 1. Toggles (Added mfi and supertrend)
+                         st.session_state.use_rsi, st.session_state.use_vol, st.session_state.use_trend, st.session_state.use_volume,
+                         st.session_state.use_macd, st.session_state.use_ma_slope, st.session_state.use_markov, 
+                         st.session_state.use_mfi, st.session_state.use_supertrend, 
+                         # 2. Weights (Added mfi and supertrend)
+                         st.session_state.rsi_w, st.session_state.vol_w, st.session_state.trend_w, st.session_state.volume_w,
+                         st.session_state.macd_w, st.session_state.ma_slope_w, st.session_state.markov_w, 
+                         st.session_state.mfi_w, st.session_state.supertrend_w, 
+                         # 3. Settings
+                         st.session_state.use_adx_filter, st.session_state.adx_threshold,
+                         st.session_state.get('rsi_logic', 'Crossover'),
+                         st.session_state.adx_period,
+                         veto_setups_list=veto_list_to_use,
+                         primary_driver=st.session_state.primary_driver,
+                         markov_setup=markov_setup_to_use,
+                         exit_logic_type=exit_logic, 
+                         exit_confidence_threshold=exit_thresh,
+                         smart_trailing_stop_pct=smart_trailing_stop,
+                         smart_exit_atr_period=smart_atr_p,
+                         smart_exit_atr_multiplier=smart_atr_m,
+                         intelligent_tsl_pct=intelligent_tsl,
+                         # 4. Start Date Filter (Crucial for matching warmup logic)
+                         analysis_start_date=user_start_date 
+                     )
                          st.session_state.single_ticker_results = {"long_pnl": long_pnl, "short_pnl": short_pnl, "avg_long_trade": avg_long_trade, "avg_short_trade": avg_short_trade, "results_df": results_df, "trades": trades}
                          st.session_state.open_trades_df = pd.DataFrame(open_trades) if open_trades else pd.DataFrame()
                          st.session_state.exit_breakdown_totals = {'long_profit_take_count': exit_breakdown[0], 'long_tsl_count': exit_breakdown[1], 'long_time_exit_count': exit_breakdown[2], 'short_profit_take_count': exit_breakdown[3], 'short_tsl_count': exit_breakdown[4], 'short_time_exit_count': exit_breakdown[5]}
@@ -4306,18 +4440,20 @@ def main():
                         ticker_data_series = ticker_data_series.rename(columns={k:v for k,v in rename_dict.items() if k in existing_cols})
 
                         if not ticker_data_series.empty and 'Close' in ticker_data_series.columns and not ticker_data_series['Close'].isna().all():
-                            long_pnl, short_pnl, avg_long_trade, avg_short_trade, _, trades, open_trades, trade_counts, durations, trade_dates, exit_breakdown = run_backtest(
-                                ticker_data_series, manual_params,
+                            long_pnl, short_pnl, avg_long_trade, avg_short_trade, results_df, trades, open_trades, trade_counts, durations, trade_dates, exit_breakdown = run_backtest(
+                                ticker_data_series, manual_params,  # <--- THIS WAS THE ERROR SOURCE
                                 st.session_state.use_rsi, st.session_state.use_vol, st.session_state.use_trend, st.session_state.use_volume,
-                                st.session_state.use_macd, st.session_state.use_ma_slope, st.session_state.use_markov,
+                                st.session_state.use_macd, st.session_state.use_ma_slope, st.session_state.use_markov, 
+                                st.session_state.use_mfi, st.session_state.use_supertrend, # Added MFI/ST
                                 st.session_state.rsi_w, st.session_state.vol_w, st.session_state.trend_w, st.session_state.volume_w,
-                                st.session_state.macd_w, st.session_state.ma_slope_w, st.session_state.markov_w,
+                                st.session_state.macd_w, st.session_state.ma_slope_w, st.session_state.markov_w, 
+                                st.session_state.mfi_w, st.session_state.supertrend_w, # Added MFI/ST weights
                                 st.session_state.use_adx_filter, st.session_state.adx_threshold, st.session_state.get('rsi_logic', 'Crossover'), st.session_state.adx_period, 
                                 veto_setups_list=veto_list_to_use, primary_driver=st.session_state.primary_driver,
                                 markov_setup=markov_setup_to_use, exit_logic_type=exit_logic, exit_confidence_threshold=exit_thresh,
                                 smart_trailing_stop_pct=smart_trailing_stop, smart_exit_atr_period=smart_atr_p,
                                 smart_exit_atr_multiplier=smart_atr_m, intelligent_tsl_pct=intelligent_tsl,
-                                analysis_start_date=user_start_date # <--- Pass the filter date
+                                analysis_start_date=user_start_date
                             )
 
                             if abs(long_pnl) > PROFIT_THRESHOLD or abs(short_pnl) > PROFIT_THRESHOLD or \
@@ -4467,7 +4603,7 @@ def main():
             if st.button("💾 Add these settings to User-Defined List", key="save_setup_from_analysis", on_click=add_setup_to_user_list): pass
 
         # 5. Open Positions Table (With Filter)
-        st.subheader("👨🏽‍💼 Open Positions & Recently Closed", 
+        st.subheader("👨🏻‍💼 Open Positions & Recently Closed", 
                      help="This table displays all currently ACTIVE trades, plus any trades that closed within the last 30 days.")
         
         if st.session_state.get('open_trades_df') is not None and not st.session_state.open_trades_df.empty: