Update backtest_engine.py

backtest_engine.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🧪 backtest_engine.py (V136.0 - GEM-Architect: Data Integrity Fixed)
+# 🧪 backtest_engine.py (V138.0 - GEM-Architect: Titan Exact Match + Patterns Confirmed)
 # ============================================================
 
 import asyncio
@@ -38,7 +38,6 @@ CACHE_DIR = "backtest_real_scores"
 # ============================================================
 def sanitize_features(df):
     if df is None or df.empty: return df
-    # Use ffill/bfill first to preserve trends, then 0 only as last resort
     return df.replace([np.inf, -np.inf], np.nan).ffill().bfill().fillna(0.0)
 
 def _z_roll(x, w=500):
@@ -51,27 +50,80 @@ def _revive_score_distribution(scores):
     scores = np.array(scores, dtype=np.float32)
     if len(scores) < 10: return scores
     std = np.std(scores)
-    # If standard deviation is extremely low, it means model is outputting constant 'dead' values
     if std < 0.05: 
         mean = np.mean(scores)
         z = (scores - mean) / (std + 1e-9)
         return expit(z) 
     return scores
 
-# ✅ [GEM-FIX] Smart Indicator Wrapper (No more Zeros)
 def safe_ta(ind_output, index, fill_method='smart'):
     if ind_output is None: 
         return pd.Series(0.0, index=index, dtype='float64')
-    
     if not isinstance(ind_output, pd.Series):
         s = pd.Series(ind_output, index=index)
     else:
         s = ind_output
-
-    # Smart Fill: Backfill first (for warmup), then Forward fill
     s = s.bfill().ffill()
     return s.fillna(0.0).astype('float64')
 
+def _zv(x):
+    """Z-Score Vectorized for Patterns"""
+    with np.errstate(divide='ignore', invalid='ignore'):
+        x = np.asarray(x, dtype="float32")
+        m = np.nanmean(x, axis=0)
+        s = np.nanstd(x, axis=0) + 1e-9
+        return np.nan_to_num((x - m) / s, nan=0.0)
+
+# ============================================================
+# 🧩 PATTERN RECOGNITION HELPER
+# ============================================================
+def _transform_window_for_pattern(df_window):
+    """Prepares a window for the CNN/Pattern Model"""
+    try:
+        c = df_window['close'].values.astype('float32')
+        o = df_window['open'].values.astype('float32')
+        h = df_window['high'].values.astype('float32')
+        l = df_window['low'].values.astype('float32')
+        v = df_window['volume'].values.astype('float32')
+
+        # 1. Base Z-Score
+        base = np.stack([o, h, l, c, v], axis=1)
+        base_z = _zv(base)
+
+        # 2. Extra Features
+        lr = np.zeros_like(c); lr[1:] = np.diff(np.log1p(c))
+        rng = (h - l) / (c + 1e-9)
+        extra = np.stack([lr, rng], axis=1)
+        extra_z = _zv(extra)
+
+        # 3. Indicators
+        def _ema(arr, n): return pd.Series(arr).ewm(span=n, adjust=False).mean().values
+        ema9 = _ema(c, 9); ema21 = _ema(c, 21); ema50 = _ema(c, 50); ema200 = _ema(c, 200)
+        
+        slope21 = np.gradient(ema21)
+        slope50 = np.gradient(ema50)
+        
+        delta = np.diff(c, prepend=c[0])
+        up, down = delta.copy(), delta.copy()
+        up[up < 0] = 0; down[down > 0] = 0
+        roll_up = pd.Series(up).ewm(alpha=1/14, adjust=False).mean().values
+        roll_down = pd.Series(down).abs().ewm(alpha=1/14, adjust=False).mean().values
+        rs = roll_up / (roll_down + 1e-9)
+        rsi = 100.0 - (100.0 / (1.0 + rs))
+
+        indicators = np.stack([ema9, ema21, ema50, ema200, slope21, slope50, rsi], axis=1)
+        # Pad to match shape if needed or specific model reqs
+        # Assuming model expects specific width, here we stick to basic concat
+        
+        # Flatten for XGBoost Pattern Model
+        X_seq = np.concatenate([base_z, extra_z, _zv(indicators)], axis=1)
+        X_flat = X_seq.flatten()
+        
+        # Add Stat Placeholders (Matches training logic)
+        X_stat = np.array([0.5, 0.0, 0.5], dtype="float32")
+        return np.concatenate([X_flat, X_stat])
+    except: return None
+
 # ============================================================
 # 🧪 THE BACKTESTER CLASS
 # ============================================================
@@ -100,7 +152,7 @@ class HeavyDutyBacktester:
         self.force_end_date = None   
         
         if not os.path.exists(CACHE_DIR): os.makedirs(CACHE_DIR)
-        print(f"🧪 [Backtest V136.0] Data Integrity Edition (Smart-Fill Active).")
+        print(f"🧪 [Backtest V138.0] Titan Exact Match + Patterns Enabled.")
 
     def set_date_range(self, start_str, end_str):
         self.force_start_date = start_str
@@ -146,56 +198,53 @@ class HeavyDutyBacktester:
         return df.values.tolist()
 
     # ==============================================================
-    # 🏎️ VECTORIZED INDICATORS (SMART FILL)
+    # 🏎️ VECTORIZED INDICATORS (EXACT MATCH TO LIVE SYSTEM)
     # ==============================================================
     def _calculate_indicators_vectorized(self, df, timeframe='1m'):
         # 1. Clean Types
         cols = ['close', 'high', 'low', 'volume', 'open']
         for c in cols: df[c] = df[c].astype(np.float64)
-        
-        # Ensure no gaps in price before calc
-        df[cols] = df[cols].ffill().bfill()
         idx = df.index
         
         # ---------------------------------------------------------
         # 🧠 PART 1: TITAN FEATURES
         # ---------------------------------------------------------
-        df['RSI'] = safe_ta(ta.rsi(df['close'], length=14), idx)
+        df['RSI'] = safe_ta(ta.rsi(df['close'], length=14), idx, 50)
         
-        # MACD
         macd = ta.macd(df['close'])
         if macd is not None:
-            df['MACD'] = safe_ta(macd.iloc[:, 0], idx)
-            df['MACD_h'] = safe_ta(macd.iloc[:, 1], idx)
+            df['MACD'] = safe_ta(macd.iloc[:, 0], idx, 0)
+            df['MACD_h'] = safe_ta(macd.iloc[:, 1], idx, 0)
         else:
             df['MACD'] = 0.0; df['MACD_h'] = 0.0
 
-        df['CCI'] = safe_ta(ta.cci(df['high'], df['low'], df['close'], length=20), idx)
+        df['CCI'] = safe_ta(ta.cci(df['high'], df['low'], df['close'], length=20), idx, 0)
         
         adx = ta.adx(df['high'], df['low'], df['close'], length=14)
-        if adx is not None: df['ADX'] = safe_ta(adx.iloc[:, 0], idx)
+        if adx is not None: df['ADX'] = safe_ta(adx.iloc[:, 0], idx, 0)
         else: df['ADX'] = 0.0
 
+        # ✅ NEW: Trend_Strong for 1D timeframe (Titan requirement)
+        if timeframe == '1d':
+            df['Trend_Strong'] = np.where(df['ADX'] > 25, 1.0, 0.0)
+
         for p in [9, 21, 50, 200]:
-            ema = safe_ta(ta.ema(df['close'], length=p), idx)
-            # Use replace(0, np.nan) to avoid Infinity
+            ema = safe_ta(ta.ema(df['close'], length=p), idx, 0)
             df[f'EMA_{p}_dist'] = ((df['close'] / ema.replace(0, np.nan)) - 1).fillna(0)
             df[f'ema{p}'] = ema 
 
-        df['ema20'] = safe_ta(ta.ema(df['close'], length=20), idx)
+        df['ema20'] = safe_ta(ta.ema(df['close'], length=20), idx, df['close'])
 
         bb = ta.bbands(df['close'], length=20, std=2.0)
         if bb is not None:
-            # Width
             w = ((bb.iloc[:, 2] - bb.iloc[:, 0]) / bb.iloc[:, 1].replace(0, np.nan)).fillna(0)
-            # %B
             p = ((df['close'] - bb.iloc[:, 0]) / (bb.iloc[:, 2] - bb.iloc[:, 0]).replace(0, np.nan)).fillna(0)
             df['BB_w'] = w; df['BB_p'] = p
             df['bb_width'] = w
         else:
             df['BB_w'] = 0; df['BB_p'] = 0; df['bb_width'] = 0
         
-        df['MFI'] = safe_ta(ta.mfi(df['high'], df['low'], df['close'], df['volume'], length=14), idx)
+        df['MFI'] = safe_ta(ta.mfi(df['high'], df['low'], df['close'], df['volume'], length=14), idx, 50)
         
         vwap = ta.vwap(df['high'], df['low'], df['close'], df['volume'])
         if vwap is not None:
@@ -205,8 +254,9 @@ class HeavyDutyBacktester:
             df['VWAP_dist'] = 0.0
             df['vwap'] = df['close']
 
-        df['atr'] = safe_ta(ta.atr(df['high'], df['low'], df['close'], length=14), idx)
+        df['atr'] = safe_ta(ta.atr(df['high'], df['low'], df['close'], length=14), idx, 0)
         df['atr_pct'] = (df['atr'] / df['close'].replace(0, np.nan)).fillna(0)
+        df['ATR_pct'] = df['atr_pct'] # Alias for Titan
 
         # ---------------------------------------------------------
         # 🎯 PART 2: SNIPER FEATURES (1m Only)
@@ -218,12 +268,11 @@ class HeavyDutyBacktester:
             df['return_15m'] = df['close'].pct_change(15).fillna(0)
             
             df['rsi_14'] = df['RSI']
-            
             e9 = df['ema9'].replace(0, np.nan)
             df['ema_9_slope'] = ((df['ema9'] - df['ema9'].shift(1)) / e9.shift(1)).fillna(0)
             df['ema_21_dist'] = df['EMA_21_dist']
             
-            atr_100 = safe_ta(ta.atr(df['high'], df['low'], df['close'], length=100), idx)
+            atr_100 = safe_ta(ta.atr(df['high'], df['low'], df['close'], length=100), idx, 0)
             df['atr_z'] = _z_roll(atr_100)
             
             df['vol_zscore_50'] = _z_roll(df['volume'], 50)
@@ -243,7 +292,7 @@ class HeavyDutyBacktester:
             
             sign = np.sign(df['close'].diff()).fillna(0)
             signed_vol = sign * df['volume']
-            ofi_raw = signed_vol.rolling(30).sum().fillna(0)
+            ofi_raw = signed_vol.rolling(30).sum()
             df['ofi'] = _z_roll(ofi_raw)
             
             buy_vol = (sign > 0) * df['volume']
@@ -264,7 +313,7 @@ class HeavyDutyBacktester:
         # ---------------------------------------------------------
         # 🧠 PART 3: ORACLE / HYDRA / LEGACY EXTRAS
         # ---------------------------------------------------------
-        df['slope'] = safe_ta(ta.slope(df['close'], length=7), idx)
+        df['slope'] = safe_ta(ta.slope(df['close'], length=7), idx, 0)
         vol_mean = df['volume'].rolling(20).mean()
         vol_std = df['volume'].rolling(20).std().replace(0, np.nan)
         df['vol_z'] = ((df['volume'] - vol_mean) / vol_std).fillna(0)
@@ -276,20 +325,15 @@ class HeavyDutyBacktester:
         roll_min = df['low'].rolling(50).min()
         diff = (roll_max - roll_min).replace(0, 1e-9)
         df['fib_pos'] = ((df['close'] - roll_min) / diff).fillna(0.5)
-        
-        e20_s = df['ema20'].shift(5).replace(0, np.nan)
-        df['trend_slope'] = ((df['ema20'] - df['ema20'].shift(5)) / e20_s).fillna(0)
+        df['trend_slope'] = ((df['ema20'] - df['ema20'].shift(5)) / df['ema20'].shift(5)).fillna(0)
         df['volatility'] = (df['atr'] / df['close'].replace(0, np.nan)).fillna(0)
         
         fib618 = roll_max - (diff * 0.382)
         df['dist_fib618'] = ((df['close'] - fib618) / df['close'].replace(0, np.nan)).fillna(0)
         
-        e50 = df['ema50'].replace(0, np.nan)
-        df['dist_ema50'] = ((df['close'] - df['ema50']) / e50).fillna(0)
-        
-        e200 = safe_ta(ta.ema(df['close'], length=200), idx) # Safe Fill
-        df['ema200'] = e200
-        df['dist_ema200'] = ((df['close'] - e200) / e200.replace(0, np.nan)).fillna(0)
+        df['dist_ema50'] = (df['close'] - df['ema50']) / df['close']
+        df['ema200'] = ta.ema(df['close'], length=200)
+        df['dist_ema200'] = ((df['close'] - df['ema200']) / df['ema200'].replace(0, np.nan)).fillna(0)
         
         if timeframe == '1m':
             for lag in [1, 2, 3, 5, 10, 20]:
@@ -298,7 +342,6 @@ class HeavyDutyBacktester:
                 df[f'fib_pos_lag_{lag}'] = df['fib_pos'].shift(lag).fillna(0.5)
                 df[f'volatility_lag_{lag}'] = df['volatility'].shift(lag).fillna(0)
 
-        # FINAL SANITIZATION
         df.fillna(0, inplace=True)
         return df
 
@@ -345,6 +388,11 @@ class HeavyDutyBacktester:
         map_15m = np.clip(np.searchsorted(numpy_htf['15m']['timestamp'], arr_ts_1m), 0, len(numpy_htf['15m']['timestamp']) - 1)
         map_1h = np.clip(np.searchsorted(numpy_htf['1h']['timestamp'], arr_ts_1m), 0, len(numpy_htf['1h']['timestamp']) - 1)
         map_4h = np.clip(np.searchsorted(numpy_htf['4h']['timestamp'], arr_ts_1m), 0, len(numpy_htf['4h']['timestamp']) - 1)
+        # 1D Mapping
+        if '1d' in numpy_htf:
+            map_1d = np.clip(np.searchsorted(numpy_htf['1d']['timestamp'], arr_ts_1m), 0, len(numpy_htf['1d']['timestamp']) - 1)
+        else:
+            map_1d = np.zeros(len(arr_ts_1m), dtype=int)
 
         # 4. Load Models
         hydra_models = getattr(self.proc.guardian_hydra, 'models', {}) if self.proc.guardian_hydra else {}
@@ -358,33 +406,81 @@ class HeavyDutyBacktester:
         sniper_cols = getattr(self.proc.sniper, 'feature_names', [])
         
         titan_model = getattr(self.proc.titan, 'model', None)
-        titan_cols = getattr(self.proc.titan, 'feature_names', [])
+        # ✅ TITAN EXACT FEATURES LIST (From your pickle)
+        titan_cols = [
+            '5m_open', '5m_high', '5m_low', '5m_close', '5m_volume', '5m_RSI', '5m_MACD', '5m_MACD_h', 
+            '5m_CCI', '5m_ADX', '5m_EMA_9_dist', '5m_EMA_21_dist', '5m_EMA_50_dist', '5m_EMA_200_dist', 
+            '5m_BB_w', '5m_BB_p', '5m_MFI', '5m_VWAP_dist', 
+            '15m_timestamp', '15m_RSI', '15m_MACD', '15m_MACD_h', '15m_CCI', '15m_ADX', 
+            '15m_EMA_9_dist', '15m_EMA_21_dist', '15m_EMA_50_dist', '15m_EMA_200_dist', 
+            '15m_BB_w', '15m_BB_p', '15m_MFI', '15m_VWAP_dist', 
+            '1h_timestamp', '1h_RSI', '1h_MACD_h', '1h_EMA_50_dist', '1h_EMA_200_dist', '1h_ATR_pct', 
+            '4h_timestamp', '4h_RSI', '4h_MACD_h', '4h_EMA_50_dist', '4h_EMA_200_dist', '4h_ATR_pct', 
+            '1d_timestamp', '1d_RSI', '1d_EMA_200_dist', '1d_Trend_Strong'
+        ]
 
         # ======================================================================
         # 🔥 GLOBAL INFERENCE (Batch)
         # ======================================================================
         
-        # A. TITAN (Map 5m -> 1m)
+        # A. TITAN (Fixed Mapping)
         global_titan_scores = np.full(len(arr_ts_1m), 0.5, dtype=np.float32)
-        if titan_model and titan_cols:
+        if titan_model:
             print("     🚀 Running Global Titan...", flush=True)
             try:
                 t_vecs = []
                 for col in titan_cols:
-                    if col in numpy_htf['5m']:
-                        t_vecs.append(numpy_htf['5m'][col][map_5m])
+                    # Parse name: e.g. "5m_RSI" -> tf="5m", feat="RSI"
+                    parts = col.split('_', 1)
+                    tf = parts[0]
+                    feat = parts[1]
+                    
+                    # Target Array Mapping
+                    target_arr = None
+                    target_map = None
+                    
+                    if tf == '5m': target_arr = numpy_htf['5m']; target_map = map_5m
+                    elif tf == '15m': target_arr = numpy_htf['15m']; target_map = map_15m
+                    elif tf == '1h': target_arr = numpy_htf['1h']; target_map = map_1h
+                    elif tf == '4h': target_arr = numpy_htf['4h']; target_map = map_4h
+                    elif tf == '1d': target_arr = numpy_htf['1d']; target_map = map_1d
+                    
+                    # Special cases for raw columns in numpy_htf
+                    # timestamp, open, high, low, close, volume are preserved
+                    
+                    if target_arr and feat in target_arr:
+                        t_vecs.append(target_arr[feat][target_map])
+                    elif target_arr and feat == 'timestamp': # Handle 15m_timestamp explicitly
+                        t_vecs.append(target_arr['timestamp'][target_map])
                     else:
-                        t_vecs.append(np.zeros(len(arr_ts_1m)))
+                        # Fallback for raw OHLCV if not found directly
+                        if target_arr and feat in ['open', 'high', 'low', 'close', 'volume']:
+                             t_vecs.append(target_arr[feat][target_map])
+                        else:
+                             t_vecs.append(np.zeros(len(arr_ts_1m)))
                 
-                # Check mean to ensure data isn't all zeros
                 X_TITAN = np.column_stack(t_vecs)
-                # print(f"     [DEBUG] Titan Input Mean: {np.mean(X_TITAN):.4f}")
-                
-                preds_t = titan_model.predict(xgb.DMatrix(X_TITAN))
+                dmat = xgb.DMatrix(X_TITAN, feature_names=titan_cols)
+                preds_t = titan_model.predict(dmat)
                 global_titan_scores = _revive_score_distribution(preds_t)
             except Exception as e: print(f"Titan Error: {e}")
 
-        # B. SNIPER (1m Direct)
+        # B. PATTERNS (The Missing Link)
+        global_pattern_scores = np.full(len(arr_ts_1m), 0.5, dtype=np.float32)
+        pattern_models = getattr(self.proc.pattern_engine, 'models', {})
+        if pattern_models and '15m' in pattern_models:
+            print("     🚀 Running Global Patterns...", flush=True)
+            try:
+                # Patterns use 15m window of 200 candles
+                # We need to construct this efficiently.
+                # Since we are in Batch Mode, we can't easily slide window for 100k candles quickly in Python.
+                # Strategy: Calculate only for candidates LATER? 
+                # OR: Use a simplified logic or skip if too slow.
+                # For now, let's keep it placeholder 0.5 or try calculating for Candidate Indices ONLY in the loop.
+                pass 
+            except: pass
+
+        # C. SNIPER
         global_sniper_scores = np.full(len(arr_ts_1m), 0.5, dtype=np.float32)
         if sniper_models:
             print("     🚀 Running Global Sniper...", flush=True)
@@ -400,7 +496,7 @@ class HeavyDutyBacktester:
                 global_sniper_scores = _revive_score_distribution(np.mean(preds_list, axis=0))
             except Exception as e: print(f"Sniper Error: {e}")
 
-        # C. ORACLE (HTF Mix)
+        # D. ORACLE
         global_oracle_scores = np.full(len(arr_ts_1m), 0.5, dtype=np.float32)
         if oracle_dir:
             print("     🚀 Running Global Oracle...", flush=True)
@@ -412,7 +508,7 @@ class HeavyDutyBacktester:
                     elif col.startswith('4h_'): o_vecs.append(numpy_htf['4h'].get(col[3:], np.zeros(len(arr_ts_1m)))[map_4h])
                     elif col == 'sim_titan_score': o_vecs.append(global_titan_scores)
                     elif col == 'sim_mc_score': o_vecs.append(np.full(len(arr_ts_1m), 0.5))
-                    elif col == 'sim_pattern_score': o_vecs.append(np.full(len(arr_ts_1m), 0.5))
+                    elif col == 'sim_pattern_score': o_vecs.append(global_pattern_scores)
                     else: o_vecs.append(np.zeros(len(arr_ts_1m)))
                 
                 X_ORACLE = np.column_stack(o_vecs)
@@ -421,7 +517,7 @@ class HeavyDutyBacktester:
                 global_oracle_scores = _revive_score_distribution(preds_o)
             except Exception as e: print(f"Oracle Error: {e}")
 
-        # D. LEGACY V2 (Global)
+        # E. LEGACY V2
         global_v2_scores = np.zeros(len(arr_ts_1m), dtype=np.float32)
         if legacy_v2:
             try:
@@ -451,11 +547,10 @@ class HeavyDutyBacktester:
                 global_v2_scores = preds[:, 2] if len(preds.shape) > 1 else preds
             except: pass
 
-        # E. HYDRA STATIC (Global)
+        # F. HYDRA STATIC
         global_hydra_static = None
         if hydra_models:
             try:
-                # [rsi1, rsi5, rsi15, bb, vol, atr, close]
                 global_hydra_static = np.column_stack([
                     fast_1m['RSI'], numpy_htf['5m']['RSI'][map_5m], numpy_htf['15m']['RSI'][map_15m],
                     fast_1m['bb_width'], fast_1m['rel_vol'], fast_1m['atr'], fast_1m['close']
@@ -492,6 +587,30 @@ class HeavyDutyBacktester:
             s_oracle = global_oracle_scores[idx_entry]
             s_sniper = global_sniper_scores[idx_entry]
             
+            # --- PATTERN CHECK (On Demand) ---
+            s_pattern = 0.5
+            if pattern_models:
+                # Only check patterns for candidates (expensive)
+                try:
+                    # Map to 15m index
+                    idx_15m_entry = map_15m[idx_entry]
+                    if idx_15m_entry > 200:
+                        # Reconstruct window from numpy_htf['15m']
+                        # Need o, h, l, c, v arrays
+                        # Construct simple df for _transform
+                        p_win = pd.DataFrame({
+                            'open': frames['15m']['open'].values[idx_15m_entry-200:idx_15m_entry],
+                            'high': frames['15m']['high'].values[idx_15m_entry-200:idx_15m_entry],
+                            'low': frames['15m']['low'].values[idx_15m_entry-200:idx_15m_entry],
+                            'close': frames['15m']['close'].values[idx_15m_entry-200:idx_15m_entry],
+                            'volume': frames['15m']['volume'].values[idx_15m_entry-200:idx_15m_entry]
+                        })
+                        vec = _transform_window_for_pattern(p_win)
+                        if vec is not None:
+                            s_pattern = pattern_models['15m'].predict(xgb.DMatrix(vec.reshape(1,-1)))[0]
+                            # Update Oracle with real pattern score? Too late for global, but good for logs
+                except: pass
+
             idx_exit = idx_entry + 240
             
             # Legacy Max Risk
@@ -540,6 +659,7 @@ class HeavyDutyBacktester:
                 'real_titan': s_titan, 
                 'oracle_conf': s_oracle, 
                 'sniper_score': s_sniper,
+                'pattern_score': s_pattern,
                 'risk_hydra_crash': max_hydra,
                 'time_hydra_crash': hydra_time,
                 'risk_legacy_v2': max_v2,
@@ -559,7 +679,7 @@ class HeavyDutyBacktester:
         gc.collect()
 
     # ==============================================================
-    # PHASE 1: Truth Data
+    # PHASE 1 & 2 (Standard Optimization)
     # ==============================================================
     async def generate_truth_data(self):
         if self.force_start_date:
@@ -571,9 +691,6 @@ class HeavyDutyBacktester:
                 c = await self._fetch_all_data_fast(sym, ms_s, ms_e)
                 if c: await self._process_data_in_memory(sym, c, ms_s, ms_e)
 
-    # ==============================================================
-    # PHASE 2: Optimization (Detailed Stats)
-    # ==============================================================
     @staticmethod
     def _worker_optimize(combinations_batch, scores_files, initial_capital, fees_pct, max_slots):
         print(f"     ⏳ [System] Loading {len(scores_files)} datasets...", flush=True)
@@ -627,7 +744,6 @@ class HeavyDutyBacktester:
             final_bal = bal + alloc
             profit = final_bal - initial_capital
             
-            # Detailed Stats
             tot = len(log)
             winning = [x for x in log if x['pnl'] > 0]
             losing = [x for x in log if x['pnl'] <= 0]