ivolatility-backtesting 1.28__tar.gz → 1.29__tar.gz

{ivolatility_backtesting-1.28 → ivolatility_backtesting-1.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ivolatility_backtesting
-Version: 1.28
+Version: 1.29
 Summary: A universal backtesting framework for financial strategies using the IVolatility API.
 Author-email: IVolatility <support@ivolatility.com>
 Project-URL: Homepage, https://ivolatility.com

{ivolatility_backtesting-1.28 → ivolatility_backtesting-1.29}/ivolatility_backtesting/ivolatility_backtesting.py

@@ -116,9 +116,9 @@ STRATEGIES = {
         # Indicators (optional - for entry filtering)
         'indicators': [
             {
-                'name': 'iv_rank',
+                'name': 'iv_rank_ivx',  # ✅ NEW: Uses IVX data (no lookback needed!)
                 'required': False,
-                'params_from_config': ['lookback_period', 'dte_target']  # lookback_period auto-calculated from lookback_ratio
+                'params_from_config': []  # No params needed - IVX has built-in high/low!
             },
             {
                 'name': 'iv_skew',
@@ -694,6 +694,16 @@ INDICATOR_REGISTRY = {
         'cache_key_params': ['lookback_period', 'dte_target']
     },
     
+    'iv_rank_ivx': {
+        'description': 'IV Rank from IVX data (uses IVolatility pre-calculated high/low)',
+        'inputs': ['ivx_df'],  # ← Uses IVX instead of options!
+        'required_params': [],  # No lookback needed!
+        'optional_params': {'dte_target': 60},  # Not used but kept for compatibility
+        'calculator': 'calculate_iv_rank_from_ivx',
+        'outputs': ['date', 'atm_iv', 'iv_rank', 'iv_high', 'iv_low'],
+        'cache_key_params': []  # No params needed for cache key
+    },
+    
     'iv_skew': {
         'description': 'Put/Call IV Skew',
         'inputs': ['options_df'],
@@ -900,6 +910,7 @@ def calculate_iv_lean_indicator(options_df, lookback_period, dte_target, dte_tol
 def calculate_iv_rank_indicator(options_df, lookback_period, dte_target):
     """
     Calculate IV Rank timeseries (VECTORIZED!)
+    Supports MULTI-SYMBOL data (if 'symbol' column present)
     
     Args:
         options_df: Options data
@@ -907,11 +918,38 @@ def calculate_iv_rank_indicator(options_df, lookback_period, dte_target):
         dte_target: Target DTE
     
     Returns:
-        pd.DataFrame with columns: ['date', 'atm_iv', 'iv_rank', 'iv_high', 'iv_low']
+        pd.DataFrame with columns: ['date', 'symbol', 'atm_iv', 'iv_rank', 'iv_high', 'iv_low']
     """
     import pandas as pd
     import numpy as np
     
+    # Check if multi-symbol data
+    has_symbol = 'symbol' in options_df.columns
+    
+    if has_symbol:
+        # Process each symbol separately
+        all_results = []
+        for symbol in options_df['symbol'].unique():
+            symbol_df = options_df[options_df['symbol'] == symbol]
+            symbol_result = _calculate_iv_rank_single_symbol(symbol_df, lookback_period, dte_target)
+            if not symbol_result.empty:
+                symbol_result['symbol'] = symbol
+                all_results.append(symbol_result)
+        
+        if all_results:
+            return pd.concat(all_results, ignore_index=True)
+        else:
+            return pd.DataFrame()
+    else:
+        # Single symbol
+        return _calculate_iv_rank_single_symbol(options_df, lookback_period, dte_target)
+
+
+def _calculate_iv_rank_single_symbol(options_df, lookback_period, dte_target):
+    """Helper function to calculate IV Rank for a single symbol"""
+    import pandas as pd
+    import numpy as np  # Needed for np.where
+    
     trading_dates = sorted(options_df['date'].unique())
     iv_history = []
     
@@ -960,17 +998,92 @@ def calculate_iv_rank_indicator(options_df, lookback_period, dte_target):
     # ✅ VECTORIZED: Rolling high/low
     iv_df = pd.DataFrame(iv_history).sort_values('date').reset_index(drop=True)
     
-    iv_df['iv_high'] = iv_df['atm_iv'].rolling(window=lookback_period, min_periods=10).max()
-    iv_df['iv_low'] = iv_df['atm_iv'].rolling(window=lookback_period, min_periods=10).min()
+    # Use at least 50% of lookback_period as min_periods (more reliable)
+    min_periods_required = max(lookback_period // 2, 30)
+    
+    iv_df['iv_high'] = iv_df['atm_iv'].rolling(window=lookback_period, min_periods=min_periods_required).max()
+    iv_df['iv_low'] = iv_df['atm_iv'].rolling(window=lookback_period, min_periods=min_periods_required).min()
     
     # IV Rank calculation
-    iv_df['iv_rank'] = ((iv_df['atm_iv'] - iv_df['iv_low']) / 
-                        (iv_df['iv_high'] - iv_df['iv_low'])) * 100
-    iv_df['iv_rank'] = iv_df['iv_rank'].fillna(50.0)  # Default to 50% if can't calculate
+    # Avoid division by zero when high == low
+    iv_range = iv_df['iv_high'] - iv_df['iv_low']
+    iv_df['iv_rank'] = np.where(
+        iv_range > 0.001,  # Minimum range threshold
+        ((iv_df['atm_iv'] - iv_df['iv_low']) / iv_range) * 100,
+        50.0  # Default when range is too small or missing
+    )
     
     return iv_df
 
 
+def calculate_iv_rank_from_ivx(ivx_df, dte_target=None):
+    """
+    Calculate IV Rank from IVX data (uses pre-calculated high/low from IVolatility)
+    
+    ✅ ADVANTAGES over calculate_iv_rank_indicator:
+    - No lookback_period needed (IVolatility already calculated high/low over 1 year)
+    - Works from day 1 (no NaN values at start)
+    - More reliable (standardized calculation from IVolatility)
+    
+    Args:
+        ivx_df: IVX data with columns ['date', 'IVX Mean', 'IVX High', 'IVX Low']
+        dte_target: Not used, kept for compatibility with indicator framework
+    
+    Returns:
+        pd.DataFrame with columns: ['date', 'symbol', 'atm_iv', 'iv_rank', 'iv_high', 'iv_low']
+    """
+    import pandas as pd
+    import numpy as np
+    
+    # Check if multi-symbol data
+    has_symbol = 'symbol' in ivx_df.columns
+    
+    if ivx_df.empty:
+        return pd.DataFrame()
+    
+    results = []
+    
+    for _, row in ivx_df.iterrows():
+        try:
+            # Get IVX values (already calculated by IVolatility)
+            ivx_mean = float(row.get('IVX Mean', row.get('ivx_mean', np.nan)))
+            ivx_high = float(row.get('IVX High', row.get('ivx_high', np.nan)))
+            ivx_low = float(row.get('IVX Low', row.get('ivx_low', np.nan)))
+            
+            # Calculate IV Rank
+            if pd.notna(ivx_mean) and pd.notna(ivx_high) and pd.notna(ivx_low):
+                iv_range = ivx_high - ivx_low
+                if iv_range > 0.001:  # Minimum threshold
+                    iv_rank = ((ivx_mean - ivx_low) / iv_range) * 100
+                else:
+                    iv_rank = 50.0
+            else:
+                # Missing data
+                continue
+            
+            result = {
+                'date': row['date'],
+                'atm_iv': ivx_mean,
+                'iv_rank': iv_rank,
+                'iv_high': ivx_high,
+                'iv_low': ivx_low
+            }
+            
+            if has_symbol:
+                result['symbol'] = row['symbol']
+            
+            results.append(result)
+            
+        except Exception as e:
+            # Skip rows with errors
+            continue
+    
+    if not results:
+        return pd.DataFrame()
+    
+    return pd.DataFrame(results)
+
+
 def calculate_iv_skew_indicator(options_df, dte_target, delta_otm=0.25):
     """
     Calculate Put/Call IV Skew timeseries
@@ -1914,30 +2027,37 @@ class StrategyRegistry:
         contracts = position_params.get('contracts', 1)
         
         if category == 'DEBIT':
-            # DEBIT: max risk = premium paid
+            # DEBIT: max risk = premium paid (total_cost already includes contracts)
             return abs(total_cost)
         
         # CREDIT: max risk depends on strategy
+        # NOTE: total_cost is ALREADY multiplied by contracts in calculate_entry_cost()!
         if strategy_type == 'IRON_CONDOR':
             wing_width = position_params.get('wing_width', 0)
-            # Max risk = (wing_width * 100) - credit (only ONE side can lose)
+            # Max risk = (wing_width * 100 * contracts) - credit (only ONE side can lose)
             # total_cost is negative for credit, so we add it
-            return (wing_width * 100 + total_cost) * contracts  # +total_cost because it's negative
+            return (wing_width * 100 * contracts) + total_cost  # ✅ FIXED: total_cost already includes contracts
         
-        elif strategy_type in ['BULL_PUT_SPREAD', 'BEAR_CALL_SPREAD']:
+        elif strategy_type in ['BULL_PUT_SPREAD', 'BEAR_CALL_SPREAD', 'CREDIT_SPREAD']:
             spread_width = position_params.get('spread_width', 0)
-            # Max risk = (spread_width * 100) - credit
-            return (spread_width * 100 + total_cost) * contracts
+            # Max risk = (spread_width * 100 * contracts) - credit
+            return (spread_width * 100 * contracts) + total_cost  # ✅ FIXED: total_cost already includes contracts
+        
+        elif strategy_type == 'IRON_BUTTERFLY':
+            wing_width = position_params.get('wing_width', 0)
+            # Max risk = (wing_width * 100 * contracts) - credit (similar to Iron Condor)
+            return (wing_width * 100 * contracts) + total_cost  # ✅ FIXED: total_cost already includes contracts
         
         elif strategy_type == 'COVERED_CALL':
-            # Max risk = stock cost (unlimited downside, but capped by entry)
+            # Max risk = stock cost - call premium (stock can go to $0, but we keep premium)
             stock_price = position_params.get('stock_price', 0)
-            return stock_price * 100 * contracts
+            # total_cost is negative (credit from selling call), so adding it reduces risk
+            return (stock_price * 100 * contracts) + total_cost  # ✅ FIXED: subtract call premium
         
         elif strategy_type == 'CASH_SECURED_PUT':
             strike = position_params.get('strike', 0)
-            # Max risk = strike price (if stock goes to $0)
-            return (strike * 100 + total_cost) * contracts
+            # Max risk = (strike * contracts) - premium (if stock goes to $0)
+            return (strike * 100 * contracts) + total_cost  # ✅ FIXED: total_cost already includes contracts
         
         else:
             # Default: assume max risk is 2x credit (conservative)
@@ -4239,11 +4359,13 @@ class PositionManager:
             'exit_date': exit_date,
             'symbol': position['symbol'],
             'signal': position['type'],
+            'type': position.get('type', ''),  # ✅ CRITICAL: Export 'type' field (BUY_IRON_CONDOR/SELL_IRON_CONDOR)
             'entry_price': position['entry_price'],
             'exit_price': exit_price,
             'quantity': position['quantity'],
             'pnl': pnl,
             'return_pct': pnl_pct,
+            'pnl_pct': pnl_pct,  # ✅ CRITICAL: Export 'pnl_pct' (same as return_pct for compatibility)
             'exit_reason': close_reason,
             'stop_type': self.sl_config.get('type', 'none') if self.sl_enabled else 'none',
             **kwargs
@@ -4257,21 +4379,37 @@ class PositionManager:
                     'short_strike', 'long_strike',  # For spreads (iron condor, butterfly, etc.)
                     'short_expiration', 'long_expiration',  # For calendar spreads (different expirations)
                     'opt_type', 'spread_type',
+                    # ✅ CRITICAL: Iron Condor strikes (4 legs)
+                    'short_call_strike', 'long_call_strike', 'short_put_strike', 'long_put_strike',
+                    # ✅ CRITICAL: Position metadata
+                    'dte', 'position_size_pct', 'total_cost', 'strategy_type',
+                    'capital_at_entry', 'target_allocation', 'actual_allocation',
+                    'available_equity_at_entry', 'locked_capital_at_entry', 'open_positions_at_entry',
+                    'highest_price', 'lowest_price',
                     # IV Lean specific
                     'entry_z_score', 'entry_lean', 'exit_lean', 'iv_lean_entry',
                     # IV data
                     'call_iv_entry', 'put_iv_entry', 'iv_entry',
                     'iv_rank_entry', 'iv_percentile_entry',
+                    # Iron Condor IV at entry (4 separate legs)
+                    'short_call_iv_entry', 'long_call_iv_entry', 'short_put_iv_entry', 'long_put_iv_entry',
                     # Greeks at entry (✅ EXPORTED AT ENTRY!)
                     'call_vega_entry', 'call_theta_entry', 'put_vega_entry', 'put_theta_entry',
                     'call_delta_entry', 'call_gamma_entry', 'put_delta_entry', 'put_gamma_entry',
                     'net_delta_entry', 'net_gamma_entry', 'net_vega_entry', 'net_theta_entry',
+                    # Iron Condor Greeks at entry (4 separate legs)
+                    'short_call_delta_entry', 'short_call_gamma_entry', 'short_call_vega_entry', 'short_call_theta_entry',
+                    'long_call_delta_entry', 'long_call_gamma_entry', 'long_call_vega_entry', 'long_call_theta_entry',
+                    'short_put_delta_entry', 'short_put_gamma_entry', 'short_put_vega_entry', 'short_put_theta_entry',
+                    'long_put_delta_entry', 'long_put_gamma_entry', 'long_put_vega_entry', 'long_put_theta_entry',
                     # Entry criteria (universal for all strategies)
                     'target_delta_entry', 'delta_threshold_entry',
                     'entry_price_pct', 'distance_from_strike_entry',
                     'dte_entry', 'target_dte_entry',
                     'volume_entry', 'open_interest_entry', 'volume_ratio_entry',
-                    'entry_criteria', 'entry_signal', 'entry_reason']:
+                    'entry_criteria', 'entry_signal', 'entry_reason',
+                    # High Vega specific entry data
+                    'entry_iv_rank', 'entry_signal_type', 'entry_wing_width', 'entry_vega_per_contract']:
             if key in position:
                 trade[key] = position[key]
         
@@ -4280,6 +4418,11 @@ class PositionManager:
                     # Call/Put entry prices (for straddle/strangle strategies)
                     'call_entry_bid', 'call_entry_ask', 'call_entry_mid',
                     'put_entry_bid', 'put_entry_ask', 'put_entry_mid',
+                    # Iron Condor entry prices (4 separate legs)
+                    'short_call_entry_bid', 'short_call_entry_ask', 'short_call_entry_mid',
+                    'long_call_entry_bid', 'long_call_entry_ask', 'long_call_entry_mid',
+                    'short_put_entry_bid', 'short_put_entry_ask', 'short_put_entry_mid',
+                    'long_put_entry_bid', 'long_put_entry_ask', 'long_put_entry_mid',
                     'underlying_entry_price']:
             if key in position:
                 trade[key] = position[key]
@@ -4288,17 +4431,29 @@ class PositionManager:
                     'long_exit_bid', 'long_exit_ask',
                     # Call/Put exit prices (for straddle/strangle strategies)
                     'call_exit_bid', 'call_exit_ask', 'put_exit_bid', 'put_exit_ask',
+                    # Iron Condor exit prices (4 separate legs)
+                    'short_call_exit_bid', 'short_call_exit_ask',
+                    'long_call_exit_bid', 'long_call_exit_ask',
+                    'short_put_exit_bid', 'short_put_exit_ask',
+                    'long_put_exit_bid', 'long_put_exit_ask',
                     'underlying_exit_price', 'underlying_change_pct',
                     'stop_threshold', 'actual_value',
                     # IV data at exit
                     'call_iv_exit', 'put_iv_exit', 'iv_lean_exit', 'iv_exit',
                     'iv_rank_exit', 'iv_percentile_exit',
+                    # Iron Condor IV at exit (4 separate legs)
+                    'short_call_iv_exit', 'long_call_iv_exit', 'short_put_iv_exit', 'long_put_iv_exit',
                     # IV Lean Z-score at exit (for IV Lean strategies)
                     'exit_z_score',
                     # Greeks at exit (✅ EXPORTED AT EXIT!)
                     'call_vega_exit', 'call_theta_exit', 'put_vega_exit', 'put_theta_exit',
                     'call_delta_exit', 'call_gamma_exit', 'put_delta_exit', 'put_gamma_exit',
                     'net_delta_exit', 'net_gamma_exit', 'net_vega_exit', 'net_theta_exit',
+                    # Iron Condor Greeks at exit (4 separate legs)
+                    'short_call_delta_exit', 'short_call_gamma_exit', 'short_call_vega_exit', 'short_call_theta_exit',
+                    'long_call_delta_exit', 'long_call_gamma_exit', 'long_call_vega_exit', 'long_call_theta_exit',
+                    'short_put_delta_exit', 'short_put_gamma_exit', 'short_put_vega_exit', 'short_put_theta_exit',
+                    'long_put_delta_exit', 'long_put_gamma_exit', 'long_put_vega_exit', 'long_put_theta_exit',
                     # Exit criteria (universal for all strategies)
                     'target_delta_exit', 'delta_threshold_exit',
                     'exit_price_pct', 'distance_from_strike_exit',
@@ -5824,75 +5979,114 @@ def create_stoploss_charts(analyzer, filename='stoploss_analysis.png', show_plot
 # RESULTS EXPORTER (unchanged)
 # ============================================================
 # ============================================================
-# OPTIMAL COLUMN ORDER (130 columns)
+# OPTIMAL COLUMN ORDER (150+ columns) - ✅ Added Iron Condor support
 # ============================================================
 OPTIMAL_COLUMN_ORDER = [
     # 1. IDENTIFIERS (4)
     'entry_date', 'exit_date', 'symbol', 'signal',
     
-    # 2. RESULTS (4)
+    # 2. RESULTS (6) - Added type and pnl_pct
     'pnl', 'return_pct', 'exit_reason', 'stop_type',
+    'type',  # ✅ BUY_IRON_CONDOR / SELL_IRON_CONDOR
+    'pnl_pct',  # ✅ P&L percentage (same as return_pct for compatibility)
     
-    # 3. OPTION PARAMETERS (14) - Added quantity after contracts
+    # 3. OPTION PARAMETERS (18) - Added Iron Condor strikes
     'strike', 'call_strike', 'put_strike',
     'expiration', 'call_expiration', 'put_expiration',
     'contracts', 'quantity',
     'short_strike', 'long_strike',
     'short_expiration', 'long_expiration',
     'opt_type', 'spread_type',
+    # ✅ Iron Condor strikes (4 legs)
+    'short_call_strike', 'long_call_strike',
+    'short_put_strike', 'long_put_strike',
     
-    # 4. ENTRY PRICES (13)
+    # 4. POSITION METADATA (12) - ✅ Iron Condor specific
+    'dte', 'position_size_pct', 'total_cost', 'strategy_type',
+    'capital_at_entry', 'target_allocation', 'actual_allocation',
+    'available_equity_at_entry', 'locked_capital_at_entry', 'open_positions_at_entry',
+    'highest_price', 'lowest_price',
+    
+    # 5. ENTRY PRICES (25) - Added Iron Condor 4 legs
     'entry_price', 'underlying_entry_price',
     'call_entry_bid', 'call_entry_ask', 'call_entry_mid',
     'put_entry_bid', 'put_entry_ask', 'put_entry_mid',
     'short_entry_bid', 'short_entry_ask', 'short_entry_mid',
     'long_entry_bid', 'long_entry_ask', 'long_entry_mid',
+    # ✅ Iron Condor entry prices (4 legs × 3 prices)
+    'short_call_entry_bid', 'short_call_entry_ask', 'short_call_entry_mid',
+    'long_call_entry_bid', 'long_call_entry_ask', 'long_call_entry_mid',
+    'short_put_entry_bid', 'short_put_entry_ask', 'short_put_entry_mid',
+    'long_put_entry_bid', 'long_put_entry_ask', 'long_put_entry_mid',
     
-    # 5. ENTRY METRICS (8)
+    # 6. ENTRY METRICS (11) - Added Iron Condor IV
     'entry_z_score', 'entry_lean', 'iv_lean_entry',
     'call_iv_entry', 'put_iv_entry', 'iv_entry',
     'iv_rank_entry', 'iv_percentile_entry',
+    # ✅ Iron Condor entry IV (4 legs)
+    'short_call_iv_entry', 'long_call_iv_entry',
+    'short_put_iv_entry', 'long_put_iv_entry',
     
-    # 6. ENTRY GREEKS (12)
+    # 7. ENTRY GREEKS (28) - Added Iron Condor Greeks
     'call_delta_entry', 'call_gamma_entry', 'call_vega_entry', 'call_theta_entry',
     'put_delta_entry', 'put_gamma_entry', 'put_vega_entry', 'put_theta_entry',
     'net_delta_entry', 'net_gamma_entry', 'net_vega_entry', 'net_theta_entry',
+    # ✅ Iron Condor entry Greeks (4 legs × 4 greeks)
+    'short_call_delta_entry', 'short_call_gamma_entry', 'short_call_vega_entry', 'short_call_theta_entry',
+    'long_call_delta_entry', 'long_call_gamma_entry', 'long_call_vega_entry', 'long_call_theta_entry',
+    'short_put_delta_entry', 'short_put_gamma_entry', 'short_put_vega_entry', 'short_put_theta_entry',
+    'long_put_delta_entry', 'long_put_gamma_entry', 'long_put_vega_entry', 'long_put_theta_entry',
     
-    # 7. ENTRY CRITERIA (12)
+    # 8. ENTRY CRITERIA (15) - Added Iron Condor signals
     'target_delta_entry', 'delta_threshold_entry',
     'entry_price_pct', 'distance_from_strike_entry',
     'dte_entry', 'target_dte_entry',
     'volume_entry', 'open_interest_entry', 'volume_ratio_entry',
     'entry_criteria', 'entry_signal', 'entry_reason',
+    # ✅ Iron Condor strategy signals
+    'entry_iv_rank', 'entry_signal_type', 'entry_wing_width',
     
-    # 8. STOP-LOSS (2)
+    # 9. STOP-LOSS (2)
     'stop_threshold', 'actual_value',
     
-    # 9. EXIT PRICES (11) - Added exit_price first
+    # 10. EXIT PRICES (19) - Added Iron Condor 4 legs
     'exit_price', 'underlying_exit_price', 'underlying_change_pct',
     'call_exit_bid', 'call_exit_ask',
     'put_exit_bid', 'put_exit_ask',
             'short_exit_bid', 'short_exit_ask',
             'long_exit_bid', 'long_exit_ask',
+    # ✅ Iron Condor exit prices (4 legs × 2 prices)
+    'short_call_exit_bid', 'short_call_exit_ask',
+    'long_call_exit_bid', 'long_call_exit_ask',
+    'short_put_exit_bid', 'short_put_exit_ask',
+    'long_put_exit_bid', 'long_put_exit_ask',
     
-    # 10. EXIT METRICS (8)
+    # 11. EXIT METRICS (12) - Added Iron Condor IV
     'exit_z_score', 'exit_lean', 'iv_lean_exit',
     'call_iv_exit', 'put_iv_exit', 'iv_exit',
     'iv_rank_exit', 'iv_percentile_exit',
+    # ✅ Iron Condor exit IV (4 legs)
+    'short_call_iv_exit', 'long_call_iv_exit',
+    'short_put_iv_exit', 'long_put_iv_exit',
     
-    # 11. EXIT GREEKS (12)
+    # 12. EXIT GREEKS (28) - Added Iron Condor Greeks
     'call_delta_exit', 'call_gamma_exit', 'call_vega_exit', 'call_theta_exit',
     'put_delta_exit', 'put_gamma_exit', 'put_vega_exit', 'put_theta_exit',
     'net_delta_exit', 'net_gamma_exit', 'net_vega_exit', 'net_theta_exit',
+    # ✅ Iron Condor exit Greeks (4 legs × 4 greeks)
+    'short_call_delta_exit', 'short_call_gamma_exit', 'short_call_vega_exit', 'short_call_theta_exit',
+    'long_call_delta_exit', 'long_call_gamma_exit', 'long_call_vega_exit', 'long_call_theta_exit',
+    'short_put_delta_exit', 'short_put_gamma_exit', 'short_put_vega_exit', 'short_put_theta_exit',
+    'long_put_delta_exit', 'long_put_gamma_exit', 'long_put_vega_exit', 'long_put_theta_exit',
     
-    # 12. EXIT CRITERIA (11)
+    # 13. EXIT CRITERIA (11)
     'target_delta_exit', 'delta_threshold_exit',
     'exit_price_pct', 'distance_from_strike_exit',
     'dte_exit', 'target_dte_exit',
     'volume_exit', 'open_interest_exit', 'volume_ratio_exit',
     'exit_criteria', 'exit_signal',
     
-    # 13. INTRADAY DATA (18)
+    # 14. INTRADAY DATA (18)
     'stock_intraday_high', 'stock_intraday_low', 'stock_intraday_close',
     'stock_stop_trigger_time', 'stock_stop_trigger_price',
     'stock_stop_trigger_bid', 'stock_stop_trigger_ask', 'stock_stop_trigger_last',
@@ -5901,8 +6095,9 @@ OPTIMAL_COLUMN_ORDER = [
     'intraday_bar_index', 'intraday_volume',
     'intraday_trigger_bid_time', 'intraday_trigger_ask_time',
     
-    # 14. ADDITIONAL FIELDS (for compatibility)
+    # 15. ADDITIONAL FIELDS (for compatibility)
     'is_short_bias',
+    'underlying_price',  # ✅ Final underlying price
 ]
 
 
@@ -7752,14 +7947,15 @@ def precalculate_indicators_from_config(config, preloaded_data, param_grid=None)
 
 def build_indicator_lookup(indicator_cache, config):
     """
-    Creates unified dict for fast access to ALL indicators by date
+    Creates unified dict for fast access to ALL indicators by (symbol, date)
+    Supports multi-symbol data (if 'symbol' column present in indicator DataFrames)
     
     Args:
         indicator_cache: Dict from precalculate_indicators_from_config()
         config: Strategy config
     
     Returns:
-        dict: {date: {'z_score': 2.1, 'iv_rank': 45.2, ...}}
+        dict: {(symbol, date): {'iv_rank': 45.2, ...}} or {date: {...}} for single-symbol
     """
     strategy_type = config.get('strategy_type')
     strategy = STRATEGIES.get(strategy_type)
@@ -7768,7 +7964,13 @@ def build_indicator_lookup(indicator_cache, config):
         return {}
     
     # Unified lookup
-    by_date = {}
+    by_key = {}
+    
+    if config.get('debuginfo', 0) >= 1:
+        print(f"\n[build_indicator_lookup] Building lookup for {len(strategy['indicators'])} indicators...")
+        print(f"   Cache contains {len(indicator_cache)} entries:")
+        for cache_key in indicator_cache.keys():
+            print(f"      {cache_key}")
     
     for indicator_spec in strategy['indicators']:
         indicator_name = indicator_spec['name']
@@ -7778,6 +7980,9 @@ def build_indicator_lookup(indicator_cache, config):
         for param_name in indicator_spec.get('params_from_config', []):
             if param_name in config:
                 params[param_name] = config[param_name]
+            elif param_name == 'lookback_period':
+                # Auto-calculate from lookback_ratio
+                params[param_name] = auto_calculate_lookback_period(config, indicator_name)
         
         # Add optional params
         registry_entry = INDICATOR_REGISTRY.get(indicator_name, {})
@@ -7787,23 +7992,35 @@ def build_indicator_lookup(indicator_cache, config):
         cache_key_params = tuple(params.get(p) for p in registry_entry.get('cache_key_params', []))
         cache_key = (indicator_name, cache_key_params)
         
+        # Debug
+        if config.get('debuginfo', 0) >= 2:
+            print(f"[build_indicator_lookup] Looking for {indicator_name} with key: {cache_key}")
+            print(f"   Available keys in cache: {list(indicator_cache.keys())}")
+        
         # Find in cache
         indicator_df = indicator_cache.get(cache_key)
         if indicator_df is None or indicator_df.empty:
+            if config.get('debuginfo', 0) >= 1:
+                print(f"⚠️  Indicator '{indicator_name}' not found in cache (key: {cache_key})")
             continue
         
         # Add all fields from this indicator
         for _, row in indicator_df.iterrows():
             date = row['date']
-            if date not in by_date:
-                by_date[date] = {}
+            symbol = row.get('symbol', None)
+            
+            # Create key: (symbol, date) for multi-symbol, date for single-symbol
+            key = (symbol, date) if symbol is not None else date
+            
+            if key not in by_key:
+                by_key[key] = {}
             
-            # Add all output fields
+            # Add all output fields (exclude 'date' and 'symbol')
             for field in registry_entry.get('outputs', []):
-                if field != 'date' and field in row:
-                    by_date[date][field] = row[field]
+                if field not in ['date', 'symbol'] and field in row:
+                    by_key[key][field] = row[field]
     
-    return by_date
+    return by_key
 
 
 # ============================================================

{ivolatility_backtesting-1.28 → ivolatility_backtesting-1.29}/ivolatility_backtesting.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ivolatility_backtesting
-Version: 1.28
+Version: 1.29
 Summary: A universal backtesting framework for financial strategies using the IVolatility API.
 Author-email: IVolatility <support@ivolatility.com>
 Project-URL: Homepage, https://ivolatility.com

{ivolatility_backtesting-1.28 → ivolatility_backtesting-1.29}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ivolatility_backtesting"
-version = "1.28"
+version = "1.29"
 description = "A universal backtesting framework for financial strategies using the IVolatility API."
 readme = "README.md"
 authors = [