Upload app.py

app.py

@@ -62,7 +62,7 @@ def load_settings():
         "norm_lookback_years": 1,
         "benchmark_rank": 99,
         "use_ma_floor_filter": True,
-        
+        "catcher_stop_pct": 0.03,
         "use_vol": False, "vol_w": 0.5,
         "use_trend": False, "trend_w": 2.0,
         "use_volume": False, "volume_w": 0.5,
@@ -217,6 +217,7 @@ def load_user_setups():
         "ADX Filter": "Off",
         "Conf. Threshold": 50,
         "Large MA Period": 50, "Bollinger Band Period": 20, "Bollinger Band Std Dev": 2.0,
+        "Catcher Offset (%)": 3.0,
         "Long Entry Threshold (%)": 0.0, "Long Exit Threshold (%)": 0.0, "Long Stop Loss (%)": 8.0, "Long Delay (Days)": 0,
         "Short Entry Threshold (%)": 0.0, "Short Exit Threshold (%)": 0.0, "Short Stop Loss (%)": 8.0, "Short Delay (Days)": 0,
         "Z_Avg_Profit": 0.0, "Z_Num_Trades": 0, "Z_WL_Ratio": 0.0
@@ -585,7 +586,8 @@ def run_backtest(data, params,
                  smart_exit_atr_multiplier=3.0,
                  intelligent_tsl_pct=1.0,
                  analysis_start_date=None,
-                 analysis_end_date=None):
+                 analysis_end_date=None,
+                 benchmark_lookback_years=None):
 
     df = data.copy()
     required_cols = ['Close']
@@ -640,7 +642,7 @@ 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) ---
+    # --- [NEW] MFI & SUPERTREND CALCULATIONS (Fixed) ---
     if len(df) >= 14:
         # 1. MFI Calculation
         try:
@@ -749,22 +751,37 @@ def run_backtest(data, params,
     )
 
     if long_score_95_percentile is None:
-        long_scores_gt_zero = raw_long_score[raw_long_score > 0]
-        # [FIX] Use the variable 'benchmark_rank' instead of hardcoded 0.95
-        long_95 = long_scores_gt_zero.quantile(benchmark_rank) if not long_scores_gt_zero.empty else 1.0
+        # If user specified a lookback (e.g. 1 year), use Rolling Window
+        if benchmark_lookback_years is not None and benchmark_lookback_years > 0:
+            window_days = int(benchmark_lookback_years * 252) # Approx trading days
+            # Calculate Rolling Percentile. 'min_periods' ensures we get data early in the chart.
+            long_95 = raw_long_score.rolling(window=window_days, min_periods=50).quantile(benchmark_rank).fillna(method='bfill')
+        else:
+            # Fallback to old "Global" method if no lookback specified
+            long_scores_gt_zero = raw_long_score[raw_long_score > 0]
+            val = long_scores_gt_zero.quantile(benchmark_rank) if not long_scores_gt_zero.empty else 1.0
+            long_95 = pd.Series(val, index=df.index)
     else:
-        long_95 = long_score_95_percentile
+        long_95 = pd.Series(long_score_95_percentile, index=df.index)
 
     if short_score_95_percentile is None:
-        short_scores_gt_zero = raw_short_score[raw_short_score > 0]
-        # [FIX] Use the variable 'benchmark_rank' instead of hardcoded 0.95
-        short_95 = short_scores_gt_zero.quantile(benchmark_rank) if not short_scores_gt_zero.empty else 1.0 
+        # Same logic for Short
+        if benchmark_lookback_years is not None and benchmark_lookback_years > 0:
+            window_days = int(benchmark_lookback_years * 252)
+            short_95 = raw_short_score.rolling(window=window_days, min_periods=50).quantile(benchmark_rank).fillna(method='bfill')
+        else:
+            short_scores_gt_zero = raw_short_score[raw_short_score > 0]
+            val = short_scores_gt_zero.quantile(benchmark_rank) if not short_scores_gt_zero.empty else 1.0
+            short_95 = pd.Series(val, index=df.index)
     else:
-        short_95 = short_score_95_percentile
+        short_95 = pd.Series(short_score_95_percentile, index=df.index)
 
+    # Safety: Ensure we don't divide by zero
+    long_95 = long_95.replace(0, 1.0)
+    short_95 = short_95.replace(0, 1.0)
 
-    df['long_confidence_score'] = (raw_long_score / long_95 * 100).clip(0, 100) if long_95 > 0 else 0.0
-    df['short_confidence_score'] = (raw_short_score / short_95 * 100).clip(0, 100) if short_95 > 0 else 0.0
+    df['long_confidence_score'] = (raw_long_score / long_95 * 100).clip(0, 100).fillna(0.0)
+    df['short_confidence_score'] = (raw_short_score / short_95 * 100).clip(0, 100).fillna(0.0)
 
     apply_veto = bool(veto_setups_list)
     if apply_veto:
@@ -904,7 +921,17 @@ def run_backtest(data, params,
     df['long_entry_price_static'] = df['Close'].where(df['long_signal'].shift(1) == 0).ffill().bfill()
     df['short_entry_price_static'] = df['Close'].where(df['short_signal'].shift(1) == 0).ffill().bfill()
 
-    long_breakeven_floor = df['long_entry_price_static']; short_breakeven_floor = df['short_entry_price_static'] 
+    # [SURGICAL UPDATE START] --- Catcher Offset Logic ---
+    # We retrieve the offset percentage from params (default to 0.0 if missing)
+    catcher_offset = params.get('catcher_stop_pct', 0.0)
+    
+    # Calculate the Adjusted Floor/Ceiling
+    # Positive Offset = Higher Floor (Profit for Long, Profit for Short)
+    # Negative Offset = Lower Floor (Loss allowance for Long, Loss allowance for Short)
+    long_breakeven_floor = df['long_entry_price_static'] * (1 + catcher_offset)
+    short_breakeven_floor = df['short_entry_price_static'] * (1 - catcher_offset) 
+    # [SURGICAL UPDATE END] -----------------------------
+    
     use_ma_floor_filter = params.get('use_ma_floor_filter', False) 
     
     standard_tsl_pct_long = params.get('long_trailing_stop_loss_pct', 0)
@@ -1264,7 +1291,8 @@ def display_summary_analytics(summary_df):
 
                 st.metric("Strategy Score", f"{display_score:.2f}%")
                 st.metric("Avg Profit per Trade (Active Tickers)", f"{avg_trade_profit:.2%}")
-                st.metric(f"Average Entry Confidence", f"{avg_confidence:.0f}%")
+                net_return_pct = avg_trade_profit * total_trades * 100
+                st.metric("Net % Return", f"{net_return_pct:.1f}%", help="The total 'Pile of Money'. Sum of all trade percentages.")
 
                 st.text(f"Profitable Tickers: {good_tickers}")
                 st.text(f"Losing Tickers: {bad_tickers}")
@@ -1538,6 +1566,7 @@ def run_single_parameter_test(task_data):
         "Ticker G/B Ratio": good_bad_ratio,
         "Trade G/B Ratio": trade_good_bad_ratio,
         "Total Trades": total_trades,
+        "Net % Return": total_profit_weighted_avg * 100,
         "Avg Entry Conf.": avg_entry_confidence,
         "Winning Tickers": winning_tickers,
         "Losing Tickers": losing_tickers,
@@ -2314,11 +2343,16 @@ def run_advisor_scan(main_df, setups_to_run, advisor_type="Advisor"):
             except: long_d = 0
             try: short_d = int(setup.get("Short Delay (Days)", 0))
             except: short_d = 0
+            catcher_pct = setup.get("Catcher Offset (%)", 3.0)
+            try: catcher_decimal = float(catcher_pct) / 100.0
+            except: catcher_decimal = 0.03
+
 
             params_for_run = {
                 "large_ma_period": ma_p, "bband_period": bb_p, "long_delay_days": long_d, "short_delay_days": short_d,
                 "bband_std_dev": setup.get("Bollinger Band Std Dev", 2.0),
                 "confidence_threshold": setup.get("Conf. Threshold", 50),
+                "catcher_stop_pct": catcher_decimal,
                 "long_entry_threshold_pct": setup.get("Long Entry Threshold (%)", 0.0) / 100.0,
                 "long_exit_ma_threshold_pct": setup.get("Long Exit Threshold (%)", 0.0) / 100.0,
                 "long_trailing_stop_loss_pct": setup.get("Long Stop Loss (%)", 0.0) / 100.0,
@@ -2660,6 +2694,9 @@ def apply_best_params_to_widgets():
         
         # --- NEW: Load Max Duration ---
         if 'max_trading_days' in params: st.session_state.max_duration = params['max_trading_days']
+
+        # --- NEW: Load Catcher Offset ---
+        if 'catcher_stop_pct' in params: st.session_state.catcher_stop_pct = params['catcher_stop_pct'] * 100
         
         st.sidebar.success("Optimal parameters loaded into sidebar!")
         st.rerun() 
@@ -3118,7 +3155,18 @@ def run_confidence_optimisation(optimise_for, find_mode, master_df, main_content
             
             # --- Display the table ---
             display_df_conf = results_df.head(60)
-            conf_formatters = { "Avg Profit/Trade": "{:.2%}", "Ticker G/B Ratio": "{:.2f}", "Trade G/B Ratio": "{:.2f}", "Avg Entry Conf.": "{:.1f}%", "Good Score": "{:.4f}", "Bad Score": "{:.4f}", "Norm. Score %": "{:.2f}%" }
+            
+            # [UPDATED] Added "Net % Return" to the formatters
+            conf_formatters = { 
+                "Avg Profit/Trade": "{:.2%}", 
+                "Ticker G/B Ratio": "{:.2f}", 
+                "Trade G/B Ratio": "{:.2f}", 
+                "Net % Return": "{:.1f}%", 
+                "Avg Entry Conf.": "{:.1f}%", 
+                "Good Score": "{:.4f}", 
+                "Bad Score": "{:.4f}", 
+                "Norm. Score %": "{:.2f}%" 
+            }
             if 'MACD' in display_df_conf.columns: conf_formatters['MACD'] = '{}'
             if 'MA Slope' in display_df_conf.columns: conf_formatters['MA Slope'] = '{}'
             if 'Markov' in display_df_conf.columns: conf_formatters['Markov'] = '{}'
@@ -3165,6 +3213,7 @@ def generate_user_advisor_ui_and_run(main_df):
         "Large MA Period": st.column_config.NumberColumn("MA", width="small"),
         "Bollinger Band Period": st.column_config.NumberColumn("BB", width="small"),
         "Bollinger Band Std Dev": st.column_config.NumberColumn("Std", format="%.1f", width="small"),
+        "Catcher Offset (%)": st.column_config.NumberColumn("Catcher %", format="%.1f", width="small"),
         "Long Entry Threshold (%)": st.column_config.NumberColumn("L Entry", format="%.1f", width="small"),
         "Long Exit Threshold (%)": st.column_config.NumberColumn("L Exit", format="%.1f", width="small"),
         "Long Stop Loss (%)": st.column_config.NumberColumn("L TSL", format="%.1f", width="small"),
@@ -3187,7 +3236,7 @@ def generate_user_advisor_ui_and_run(main_df):
             "Run", "Notes", # <--- Notes column appears here (2nd)
             "RSI", "Volatility", "TREND", "Volume", "MACD", "MA Slope", "Markov", "ADX Filter",
             "Conf. Threshold",
-            "Large MA Period", "Bollinger Band Period", "Bollinger Band Std Dev",
+            "Large MA Period", "Bollinger Band Period", "Bollinger Band Std Dev","Catcher Offset (%)",
             "Long Entry Threshold (%)", "Long Exit Threshold (%)", "Long Stop Loss (%)", "Long Delay (Days)",
             "Short Entry Threshold (%)", "Short Exit Threshold (%)", "Short Stop Loss (%)", "Short Delay (Days)",
             "Z_Avg_Profit", "Z_Num_Trades", "Z_WL_Ratio"
@@ -3381,6 +3430,7 @@ def main():
         'smart_exit_atr_period': 14, 'smart_exit_atr_multiplier': 3.0,
         'intelligent_tsl_pct': 1.0,
         'use_ma_floor_filter': False,
+        'catcher_stop_pct': 0.03,
         'long_delay_days': 0, 'short_delay_days': 0,
         'long_score_95_percentile': None, 'short_score_95_percentile': None,
         'veto_setup_list': None,
@@ -3457,7 +3507,8 @@ def main():
         st.session_state.smart_exit_atr_period = defaults.get("smart_exit_atr_period", 14)
         st.session_state.smart_exit_atr_multiplier = defaults.get("smart_exit_atr_multiplier", 3.0)
         st.session_state.intelligent_tsl_pct = defaults.get("intelligent_tsl_pct", 0.60) * 100 
-
+        st.session_state.catcher_stop_pct = defaults.get("catcher_stop_pct", 0.0) * 100
+        
         # Section 3 Defaults
         st.session_state.ma_period = defaults.get("large_ma_period", 50)
         st.session_state.bb_period = defaults.get("bband_period", 20)
@@ -3935,8 +3986,18 @@ def main():
         st.sidebar.number_input("MACD Weight", 0.1, 5.0, step=0.1, key='widget_macd_w', on_change=update_state, disabled=not st.session_state.get('use_macd', True))
         
         # Confidence Slider
-        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, help="Acts as a quality filter. Higher values increase trade quality but reduce the number of trades found.")
+        # [FIX] Force the widget key to match the stored variable BEFORE creating the widget
+        st.session_state['widget_confidence_slider'] = st.session_state.confidence_slider
+        
+        # [FIX] Remove 'value=' argument. Streamlit will use the key we just populated.
+        st.sidebar.slider(
+            "Minimum Confidence Threshold (%)", 
+            0, 100, 
+            step=5, 
+            key='widget_confidence_slider', 
+            on_change=update_state, 
+            help="Acts as a quality filter. Higher values increase trade quality but reduce the number of trades found."
+        )
 
     else:
         # --- DEVELOPER VIEW (Original) ---
@@ -4011,8 +4072,17 @@ def main():
         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)
+        # [FIX] Force the widget key to match the stored variable
+        st.session_state['widget_confidence_slider'] = st.session_state.confidence_slider
+        
+        # [FIX] Remove 'value=' argument.
+        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")
@@ -4067,6 +4137,17 @@ def main():
 
         st.sidebar.toggle("Apply MA/BB Price Lock Floor (Catcher)", value=st.session_state.use_ma_floor_filter, key='widget_use_ma_floor_filter', on_change=update_state,
             help="If ON, the Trailing Stop Loss is prevented from dropping below the Mean Reversion price.")
+        # [NEW SLIDER] Catcher Offset
+        # Only visible in Developer Mode. Disabled if Catcher is OFF.
+        st.sidebar.slider(
+            "Catcher Offset (%)", 
+            min_value=-10.0, max_value=10.0, value=st.session_state.catcher_stop_pct, step=0.1, 
+            key='widget_catcher_stop_pct', on_change=update_state,
+            format="%.1f%%",
+            disabled=not st.session_state.use_ma_floor_filter,
+            help="Adjusts the hard floor level relative to Entry Price.\nPositive = Secure Profit (e.g. +1% Floor).\nNegative = Allow wiggle room (e.g. -1% Floor)."
+        )
+
         st.sidebar.markdown("---")
 
         st.sidebar.subheader("Short Trade Logic")
@@ -4243,7 +4324,8 @@ def main():
                 "rsi_logic": st.session_state.get('rsi_logic', 'Crossover'),
                 "primary_driver": st.session_state.get('primary_driver', 'Bollinger Bands'),
                 "exit_logic_type": st.session_state.get('exit_logic_type', 'Standard (Price-Based)'),
-                "use_ma_floor_filter": st.session_state.use_ma_floor_filter, 
+                "use_ma_floor_filter": st.session_state.use_ma_floor_filter,
+                "catcher_stop_pct": st.session_state.catcher_stop_pct / 100.0,
                 "exit_confidence_threshold": st.session_state.get('exit_confidence_threshold', 50),
                 "smart_trailing_stop_pct": st.session_state.get('smart_trailing_stop_pct', 5.0),
                 "smart_exit_atr_period": st.session_state.get('smart_exit_atr_period', 14),
@@ -4414,6 +4496,7 @@ def main():
                     "short_trailing_stop_loss_pct": st.session_state.get('short_sl', 8.0) / 100, 
                     "short_delay_days": st.session_state.get('short_delay', 0),
                     "use_ma_floor_filter": st.session_state.get('use_ma_floor_filter', True),
+                    "catcher_stop_pct": st.session_state.get('catcher_stop_pct', 0.0) / 100.0,
                     "max_long_duration": st.session_state.get('max_long_duration', 60),
                     "max_short_duration": st.session_state.get('max_short_duration', 10)
                 }
@@ -4509,6 +4592,7 @@ def main():
                             smart_exit_atr_multiplier=smart_atr_m,
                             intelligent_tsl_pct=intelligent_tsl,
                             benchmark_rank=benchmark_percentile_setting / 100.0,
+                            benchmark_lookback_years=norm_lookback_years, # <--- NEW PASSED VALUE
                             analysis_start_date=user_start_date,
                             analysis_end_date=end_date
                         )
@@ -4575,6 +4659,7 @@ def main():
                                 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,
                                 benchmark_rank=benchmark_percentile_setting / 100.0,
+                                benchmark_lookback_years=norm_lookback_years, # <--- NEW PASSED VALUE
                                 analysis_start_date=user_start_date,
                                 analysis_end_date=end_date
                             )