Update backtest_engine.py

backtest_engine.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🧪 backtest_engine.py (V86.0 - GEM-Architect: Parallel Integrity)
+# 🧪 backtest_engine.py (V86.1 - GEM-Architect: Debug Turbo)
 # ============================================================
 
 import asyncio
@@ -10,6 +10,8 @@ import logging
 import itertools 
 import os
 import gc 
+import sys
+import traceback
 import concurrent.futures
 from datetime import datetime, timezone
 from typing import Dict, Any, List
@@ -26,58 +28,77 @@ logging.getLogger('ml_engine').setLevel(logging.WARNING)
 CACHE_DIR = "backtest_real_scores"
 
 # ==============================================================================
-# 🚜 ISOLATED WORKER FUNCTION (Top-Level for Multiprocessing)
+# 🚜 ISOLATED WORKER FUNCTION (With Staggered Start & Debug Logs)
 # ==============================================================================
 def run_parallel_chunk(chunk_payload):
     """
-    هذه الدالة تعمل داخل عملية (Process) منفصلة تماماً.
-    تقوم بإنشاء نسختها الخاصة من DataManager و Processor لتجنب تضارب الذاكرة.
+    عامل مستقل مع إقلاع متدرج لتخفيف الضغط على الشبكة والمعالج.
     """
     symbol, start_ms, end_ms, chunk_id = chunk_payload
     
-    # 1. تهيئة بيئة معزولة (Isolated Environment)
-    # نمرر None للخدمات غير الضرورية للمحاكاة (مثل R2 و WhaleMonitor) لتخفيف الحمل
-    local_dm = DataManager(None, None, None)
-    local_proc = MLProcessor(local_dm)
-    
-    # تشغيل التهيئة (Initialize) بشكل متزامن
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
+    # 1. الإقلاع المتدرج (Staggered Start)
+    # كل عامل ينتظر (chunk_id * 2) ثانية. هذا يمنع 15 عملية من ضرب الـ API في نفس اللحظة.
+    wait_time = chunk_id * 1.5 
+    if chunk_id > 0:
+        time.sleep(wait_time)
     
+    print(f"   ⚡ [Core {chunk_id}] Init... (Waited {wait_time}s)", flush=True)
+
     try:
-        loop.run_until_complete(local_dm.initialize())
-        loop.run_until_complete(local_proc.initialize())
+        # 2. تهيئة بيئة خفيفة
+        # نمرر None لتجنب الاتصالات الثقيلة غير الضرورية، لكن DataManager يحتاج لتهيئة
+        local_dm = DataManager(None, None, None)
+        
+        # حيلة: لا نستدعي initialize الكاملة لـ DM إذا كانت تتصل بالإنترنت لجلب الأسواق
+        # فقط نهيئ http_client إذا لزم الأمر يدوياً داخل المهمة
         
+        # تهيئة المعالج
+        local_proc = MLProcessor(local_dm)
+        
+        # تشغيل حلقة الأحداث الخاصة بهذه العملية
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        
+        # تشغيل التهيئة
+        # ملاحظة: MLProcessor قد يستغرق وقتاً لتحميل النماذج
+        loop.run_until_complete(local_proc.initialize()) 
+        # local_dm.initialize() عادة يتصل بالمنصة، سنقوم بتهيئته يدوياً داخل المهمة لتجنب التعليق
+        if not local_dm.http_client:
+            import httpx
+            local_dm.http_client = httpx.AsyncClient(timeout=30.0)
+
         # إنشاء نسخة محلية من الباكتستر
         local_tester = HeavyDutyBacktester(local_dm, local_proc)
         
-        # طباعة للتبع
         dt_start = datetime.fromtimestamp(start_ms/1000, tz=timezone.utc).strftime('%Y-%m-%d')
-        print(f"   ⚡ [Core {chunk_id}] Processing: {dt_start}...", flush=True)
+        print(f"   📥 [Core {chunk_id}] Downloading Data: {dt_start}...", flush=True)
         
-        # تشغيل المهمة مع لاحقة خاصة للملف (Suffix) لتجنب الكتابة فوق الملفات الأخرى
-        # نضيف warmup (تحمية) 2000 دقيقة قبل البداية لضمان دقة المؤشرات
+        # فترة التحمية
         warmup_ms = 2000 * 60 * 1000
         actual_fetch_start = start_ms - warmup_ms
         
         success = loop.run_until_complete(
             local_tester._process_single_coin_task(
                 symbol, 
-                actual_fetch_start,  # نبدأ الجلب مبكراً
+                actual_fetch_start,  
                 end_ms, 
                 chunk_suffix=f"_part{chunk_id}",
-                analysis_start_ms=start_ms # لكن نبدأ التحليل وحفظ النتائج من هنا
+                analysis_start_ms=start_ms,
+                worker_id=chunk_id 
             )
         )
         
+        # تنظيف
         loop.run_until_complete(local_dm.close())
+        loop.close()
+        
+        print(f"   ✅ [Core {chunk_id}] Finished Chunk.", flush=True)
         return (chunk_id, success)
         
     except Exception as e:
-        print(f"   ❌ [Core {chunk_id}] Failed: {e}")
+        print(f"   ❌ [Core {chunk_id}] CRASHED: {e}", flush=True)
+        traceback.print_exc() # طباعة تفاصيل الخطأ
         return (chunk_id, False)
-    finally:
-        loop.close()
 
 # ==============================================================================
 # 🧠 Main Class
@@ -92,14 +113,12 @@ class HeavyDutyBacktester:
         self.TRADING_FEES = 0.001 
         self.MAX_SLOTS = 4         
         
-        self.TARGET_COINS = [ 
-            'SOL/USDT']
+        self.TARGET_COINS = ['SOL/USDT']
         
         self.force_start_date = None 
         self.force_end_date = None   
         
         if not os.path.exists(CACHE_DIR): os.makedirs(CACHE_DIR)
-        # print(f"🧪 [Backtest V86.0] Parallel Integrity Mode.")
 
     def set_date_range(self, start_str, end_str):
         self.force_start_date = start_str
@@ -110,38 +129,42 @@ class HeavyDutyBacktester:
         return df[['timestamp', 'open', 'high', 'low', 'close', 'volume']].values.tolist()
 
     # ==============================================================
-    # 🧱 Core Logic: Single Coin Processor (Modified for Chunks)
+    # 🧱 Core Logic: Single Coin Processor (With Progress Logs)
     # ==============================================================
-    async def _process_single_coin_task(self, sym, start_time_ms, end_time_ms, chunk_suffix="", analysis_start_ms=None):
+    async def _process_single_coin_task(self, sym, start_time_ms, end_time_ms, chunk_suffix="", analysis_start_ms=None, worker_id=0):
         safe_sym = sym.replace('/', '_')
-        # إذا لم يتم تحديد analysis_start_ms، فهو نفسه start_time_ms (للتوافق مع الاستدعاء القديم)
         if analysis_start_ms is None: analysis_start_ms = start_time_ms
         
-        # اسم الملف يعتمد على الفترة التحليلية الفعلية
         period_suffix = f"{analysis_start_ms}_{end_time_ms}{chunk_suffix}"
         scores_file = f"{CACHE_DIR}/{safe_sym}_{period_suffix}_scores.pkl"
         
         if os.path.exists(scores_file):
-            # print(f"   📂 [{sym}{chunk_suffix}] Exists.")
+            print(f"   📂 [Core {worker_id}] File Exists -> Skipping.", flush=True)
             return True
 
         t0 = time.time()
-        
         all_candles_1m = []
         df_1m = None
         frames = {}
         
+        # 1. تنزيل البيانات (الحلقة التي كانت تتوقف)
         try:
             current_since = start_time_ms
+            req_count = 0
             
             while current_since < end_time_ms:
                 try:
-                    batch = await asyncio.wait_for(
-                        self.dm.exchange.fetch_ohlcv(sym, '1m', since=current_since, limit=1000),
-                        timeout=10.0
-                    )
-                except:
-                    await asyncio.sleep(1)
+                    # إضافة مهلة وتكرار في حال الفشل
+                    batch = await self.dm.exchange.fetch_ohlcv(sym, '1m', since=current_since, limit=1000)
+                    req_count += 1
+                    
+                    # طباعة تقدم كل 5 طلبات لنعرف أن العملية حية
+                    if req_count % 5 == 0:
+                        print(f"   ⏳ [Core {worker_id}] Fetched batch {req_count}...", flush=True)
+
+                except Exception as net_err:
+                    print(f"   ⚠️ [Core {worker_id}] Network hiccup: {net_err}. Retrying in 5s...", flush=True)
+                    await asyncio.sleep(5)
                     continue
 
                 if not batch: break
@@ -152,17 +175,20 @@ class HeavyDutyBacktester:
                 all_candles_1m.extend(batch)
                 current_since = last_ts + 1
                 
-                await asyncio.sleep(0.01)
+                # تخفيف الضغط قليلاً على الـ API
+                await asyncio.sleep(0.1) 
+                
                 if current_since >= end_time_ms: break
             
-            # تصفية البيانات التي تتجاوز الوقت النهائي (للدقة)
             all_candles_1m = [c for c in all_candles_1m if c[0] <= end_time_ms]
             
             if not all_candles_1m: 
+                print(f"   ⚠️ [Core {worker_id}] No candles found.", flush=True)
                 return False
 
-            # print(f"   📥 [{chunk_suffix}] Downloaded {len(all_candles_1m)} candles.", flush=True)
+            print(f"   ⚙️ [Core {worker_id}] Processing {len(all_candles_1m)} candles...", flush=True)
 
+            # معالجة البيانات (Pandas)
             df_1m = pd.DataFrame(all_candles_1m, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
             cols = ['open', 'high', 'low', 'close', 'volume']
             df_1m[cols] = df_1m[cols].astype('float32')
@@ -171,7 +197,6 @@ class HeavyDutyBacktester:
             df_1m = df_1m.sort_index()
             
             agg_dict = {'open': 'first', 'high': 'max', 'low': 'min', 'close': 'last', 'volume': 'sum'}
-            
             df_1m_ready = df_1m.copy()
             df_1m_ready['timestamp'] = df_1m_ready.index.astype(np.int64) // 10**6
             frames['1m'] = df_1m_ready
@@ -183,21 +208,24 @@ class HeavyDutyBacktester:
                 frames[tf_str] = resampled
 
             ai_results = []
-            
-            # 🔥 المنطق المهم: نبدأ التكرار فقط من analysis_start_ms (لتجاوز فترة التحمية)
             analysis_start_dt = pd.to_datetime(analysis_start_ms, unit='ms')
             valid_indices = frames['5m'].loc[analysis_start_dt:].index 
             
+            # حلقة الذكاء الاصطناعي
+            total_steps = len(valid_indices)
+            step_count = 0
+            
             for t_idx in valid_indices:
-                # تأكد أننا لا نتجاوز الوقت النهائي المطلوب لهذا الـ Chunk
                 if t_idx.timestamp() * 1000 > end_time_ms: break
+                step_count += 1
+                
+                # طباعة تقدم المعالجة كل 20%
+                if step_count % max(1, (total_steps // 5)) == 0:
+                     print(f"   🧠 [Core {worker_id}] AI Analyzing: {step_count}/{total_steps}...", flush=True)
 
                 current_timestamp = int(t_idx.timestamp() * 1000)
-                
                 ohlcv_data = {}
                 try:
-                    # نستخدم loc للوصول للبيانات حتى اللحظة الحالية (t_idx)
-                    # هذا يضمن أن المؤشرات تحسب بناء على الماضي (بما في ذلك فترة التحمية)
                     current_slice_1m = frames['1m'].loc[:t_idx]
                     current_slice_5m = frames['5m'].loc[:t_idx]
                     current_slice_15m = frames['15m'].loc[:t_idx]
@@ -253,14 +281,13 @@ class HeavyDutyBacktester:
             dt = time.time() - t0
             if ai_results:
                 pd.DataFrame(ai_results).to_pickle(scores_file)
-                # print(f"   💾 [{sym}{chunk_suffix}] Saved {len(ai_results)} signals. (Time: {dt:.1f}s)")
-            else:
-                pass # Silent for empty chunks
+                print(f"   💾 [Core {worker_id}] Saved {len(ai_results)} signals. (Time: {dt:.1f}s)", flush=True)
             
             return True
 
         except Exception as e:
-            print(f"   ❌ [{sym}{chunk_suffix}] CRASH: {e}")
+            print(f"   ❌ [Core {worker_id}] CRASH: {e}", flush=True)
+            traceback.print_exc()
             return False
         
         finally:
@@ -270,7 +297,7 @@ class HeavyDutyBacktester:
             gc.collect()
 
     # ==============================================================
-    # PHASE 1: Main Loop (Updated for Multiprocessing)
+    # PHASE 1: Main Loop
     # ==============================================================
     async def generate_truth_data(self):
         if self.force_start_date and self.force_end_date:
@@ -279,14 +306,13 @@ class HeavyDutyBacktester:
             start_time_ms = int(dt_start.timestamp() * 1000)
             end_time_ms = int(dt_end.timestamp() * 1000)
             print(f"\n🚜 [Phase 1] Processing Era: {self.force_start_date} -> {self.force_end_date}")
-            print(f"   🚀 Turbo Mode: Engaging all CPU cores...")
+            print(f"   🚀 Turbo Mode: Engaging all CPU cores (Staggered Start)...")
         else:
             return 
         
-        # 1. تحديد عدد العمليات (Tasks)
-        # نترك نواة واحدة للنظام
         cpu_count = os.cpu_count() or 4
-        workers_count = max(1, cpu_count - 1)
+        # نستخدم عدد عمال معقول لتجنب حظر الـ API (مثلاً 10 عمال كحد أقصى)
+        workers_count = min(10, max(1, cpu_count - 1))
         
         total_duration = end_time_ms - start_time_ms
         chunk_size = total_duration // workers_count
@@ -299,98 +325,76 @@ class HeavyDutyBacktester:
                 print(f"   📂 [{sym}] Full Data Exists -> Skipping.")
                 continue
 
-            # إعداد المهام
             tasks_payload = []
             for i in range(workers_count):
                 c_start = start_time_ms + (i * chunk_size)
                 c_end = start_time_ms + ((i + 1) * chunk_size)
-                if i == workers_count - 1: c_end = end_time_ms # التأكد من تغطية النهاية
-                
+                if i == workers_count - 1: c_end = end_time_ms
                 tasks_payload.append((sym, c_start, c_end, i))
 
             print(f"   ⚡ Splitting {sym} into {workers_count} chunks...")
             
-            # تشغيل الـ ProcessPoolExecutor
             loop = asyncio.get_running_loop()
             with concurrent.futures.ProcessPoolExecutor(max_workers=workers_count) as executor:
-                # استخدام run_in_executor لتشغيل الدالة المتزامنة التي تدير العملية الفرعية
                 futures = [loop.run_in_executor(executor, run_parallel_chunk, task) for task in tasks_payload]
                 results = await asyncio.gather(*futures)
 
-            # تجميع النتائج (Merge)
             print(f"   🧩 Merging results for {sym}...")
             all_dfs = []
             for chunk_id, success in results:
                 if not success: continue
-                # استنتاج اسم الملف الجزئي
-                task = tasks_payload[chunk_id] # (sym, start, end, id)
-                part_start = task[1]
-                part_end = task[2]
+                task = tasks_payload[chunk_id]
+                part_start = task[1]; part_end = task[2]
                 part_file = f"{CACHE_DIR}/{safe_sym}_{part_start}_{part_end}_part{chunk_id}_scores.pkl"
                 
                 if os.path.exists(part_file):
                     try:
                         df_part = pd.read_pickle(part_file)
-                        if not df_part.empty:
-                            all_dfs.append(df_part)
-                        # تنظيف الملفات الجزئية
+                        if not df_part.empty: all_dfs.append(df_part)
                         os.remove(part_file)
                     except Exception as e:
                         print(f"   ⚠️ Merge Error (Part {chunk_id}): {e}")
 
             if all_dfs:
-                final_df = pd.concat(all_dfs)
-                # إزالة التكرارات وترتيب زمني
-                final_df = final_df.drop_duplicates(subset=['timestamp']).sort_values('timestamp')
+                final_df = pd.concat(all_dfs).drop_duplicates(subset=['timestamp']).sort_values('timestamp')
                 final_df.to_pickle(final_full_file)
                 print(f"   💾 [{sym}] FINAL SAVE: {len(final_df)} signals.")
             else:
-                print(f"   ⚠️ [{sym}] No signals generated in any chunk.")
+                print(f"   ⚠️ [{sym}] No signals generated.")
                 
             gc.collect()
 
     # ==============================================================
-    # PHASE 2: Portfolio Digital Twin Engine (EXACT COPY)
+    # PHASE 2: Portfolio Digital Twin Engine (Unchanged Logic)
     # ==============================================================
     @staticmethod
     def _worker_optimize(combinations_batch, scores_files, initial_capital, fees_pct, max_slots):
         results = []
         all_data = []
-        
         for fp in scores_files:
             try: 
                 df = pd.read_pickle(fp)
                 if not df.empty: all_data.append(df)
             except: pass
-        
         if not all_data: return []
-        
-        global_df = pd.concat(all_data)
-        global_df.sort_values('timestamp', inplace=True)
+        global_df = pd.concat(all_data).drop_duplicates(subset=['timestamp']).sort_values('timestamp')
         grouped_by_time = global_df.groupby('timestamp')
         
         for config in combinations_batch:
             wallet = { "balance": initial_capital, "allocated": 0.0, "positions": {}, "trades_history": [] }
-            w_titan = config['w_titan']
-            w_struct = config['w_struct']
-            entry_thresh = config['thresh']
-            
-            # Tracking Drawdown
-            peak_balance = initial_capital
-            max_drawdown = 0.0
+            w_titan = config['w_titan']; w_struct = config['w_struct']; entry_thresh = config['thresh']
+            peak_balance = initial_capital; max_drawdown = 0.0
             
             for ts, group in grouped_by_time:
                 active_symbols = list(wallet["positions"].keys())
                 current_prices = {row['symbol']: row['close'] for _, row in group.iterrows()}
-                
-                # Check Exits
+                # Exits
                 for sym in active_symbols:
                     if sym in current_prices:
                         curr_p = current_prices[sym]
                         pos = wallet["positions"][sym]
                         entry_p = pos['entry_price']
                         pct_change = (curr_p - entry_p) / entry_p
-                        
                         if pct_change >= 0.03 or pct_change <= -0.02:
                             gross_pnl = pos['size_usd'] * pct_change
                             fees = pos['size_usd'] * fees_pct * 2
@@ -399,57 +403,45 @@ class HeavyDutyBacktester:
                             wallet["balance"] += net_pnl
                             del wallet["positions"][sym]
                             wallet["trades_history"].append({'pnl': net_pnl})
-
-                current_total_equity = wallet["balance"] 
+                # Entries
+                current_total_equity = wallet["balance"] + wallet["allocated"] 
                 if current_total_equity > peak_balance: peak_balance = current_total_equity
                 dd = (peak_balance - current_total_equity) / peak_balance
                 if dd > max_drawdown: max_drawdown = dd
 
-                # Check Entries
                 if len(wallet["positions"]) < max_slots:
-                    free_capital = wallet["balance"] - wallet["allocated"]
+                    free_capital = wallet["balance"]
                     slots_left = max_slots - len(wallet["positions"])
-                    
                     if slots_left > 0 and free_capital > 2.0:
                         position_size = wallet["balance"] / max_slots
                         if wallet["balance"] < 20.0: position_size = free_capital / slots_left
                         position_size = min(position_size, free_capital)
-
                         for _, row in group.iterrows():
                             sym = row['symbol']
                             if sym in wallet["positions"]: continue
-                            
                             sig_type = row['signal_type']
                             l1_raw_score = row['l1_score']
                             real_titan = row['real_titan']
-                            
                             norm_struct = 0.0
                             if sig_type == 'BREAKOUT': norm_struct = min(1.0, l1_raw_score / 3.0) 
                             elif sig_type == 'REVERSAL': norm_struct = l1_raw_score / 100.0
-                            
                             score = 0.0
                             if (w_titan + w_struct) > 0:
                                 score = ((real_titan * w_titan) + (norm_struct * w_struct)) / (w_titan + w_struct)
-                            
                             if score >= entry_thresh:
                                 wallet["positions"][sym] = {'entry_price': row['close'], 'size_usd': position_size}
                                 wallet["allocated"] += position_size
+                                wallet["balance"] -= position_size
                                 if len(wallet["positions"]) >= max_slots: break
-                
                 if wallet["balance"] < 1.0 and len(wallet["positions"]) == 0: break
 
             trades = wallet["trades_history"]
             if trades:
-                net_profit = wallet["balance"] - initial_capital
+                net_profit = wallet["balance"] - initial_capital + wallet["allocated"]
                 pnls = [t['pnl'] for t in trades]
-                wins = [p for p in pnls if p > 0]
-                losses = [p for p in pnls if p <= 0]
-                
-                win_count = len(wins); loss_count = len(losses)
-                total_trades = len(trades)
-                win_rate = (win_count / total_trades) * 100 if total_trades > 0 else 0
-                max_single_win = max(pnls) if pnls else 0.0
-                max_single_loss = min(pnls) if pnls else 0.0
+                win_count = len([p for p in pnls if p > 0]); loss_count = len([p for p in pnls if p <= 0])
+                win_rate = (win_count / len(trades)) * 100
+                max_single_win = max(pnls) if pnls else 0.0; max_single_loss = min(pnls) if pnls else 0.0
                 
                 current_win_streak = 0; max_win_streak = 0
                 current_loss_streak = 0; max_loss_streak = 0
@@ -462,12 +454,9 @@ class HeavyDutyBacktester:
                         if current_loss_streak > max_loss_streak: max_loss_streak = current_loss_streak
 
                 results.append({
-                    'config': config,
-                    'final_balance': wallet["balance"],
-                    'net_profit': net_profit,
-                    'total_trades': total_trades,
-                    'win_count': win_count, 'loss_count': loss_count,
-                    'win_rate': win_rate,
+                    'config': config, 'final_balance': wallet["balance"] + wallet["allocated"],
+                    'net_profit': net_profit, 'total_trades': len(trades),
+                    'win_count': win_count, 'loss_count': loss_count, 'win_rate': win_rate,
                     'max_single_win': max_single_win, 'max_single_loss': max_single_loss,
                     'max_win_streak': max_win_streak, 'max_loss_streak': max_loss_streak,
                     'max_drawdown': max_drawdown * 100
@@ -479,7 +468,6 @@ class HeavyDutyBacktester:
                      'max_single_win': 0.0, 'max_single_loss': 0.0, 'max_win_streak': 0, 
                      'max_loss_streak': 0, 'max_drawdown': 0.0
                  })
-
         return results
 
     async def run_optimization(self, target_regime="RANGE"):
@@ -489,19 +477,16 @@ class HeavyDutyBacktester:
         end_ts = int(datetime.strptime(self.force_end_date, "%Y-%m-%d").replace(tzinfo=timezone.utc).timestamp() * 1000)
         period_id = f"{start_ts}_{end_ts}"
         
-        # البحث عن الملف النهائي الكامل (وليس الأجزاء partX)
         current_period_files = []
         for f in os.listdir(CACHE_DIR):
             if f.endswith('_scores.pkl') and period_id in f and "_part" not in f:
                 current_period_files.append(os.path.join(CACHE_DIR, f))
 
         if not current_period_files:
-            print(f"❌ No signals for {target_regime}.")
+            print(f"❌ No combined signal data found for {target_regime}.")
             return None, None
 
         print(f"\n🧩 [Phase 2] Optimizing for {target_regime}...")
-        print(f"   💰 Start Capital: ${self.INITIAL_CAPITAL}")
-        
         w_titan_range = np.linspace(0.4, 0.9, num=self.GRID_DENSITY)
         w_struct_range = np.linspace(0.1, 0.6, num=self.GRID_DENSITY)
         thresh_range = np.linspace(0.20, 0.60, num=self.GRID_DENSITY)
@@ -515,7 +500,6 @@ class HeavyDutyBacktester:
         batch_size = max(20, len(combinations) // (os.cpu_count() * 2))
         batches = [combinations[i:i+batch_size] for i in range(0, len(combinations), batch_size)]
         
-        # المرحلة الثانية تستخدم ProcessPoolExecutor أيضاً
         with concurrent.futures.ProcessPoolExecutor() as executor:
             futures = [executor.submit(self._worker_optimize, batch, current_period_files, 
                                        self.INITIAL_CAPITAL, self.TRADING_FEES, self.MAX_SLOTS) 
@@ -525,74 +509,44 @@ class HeavyDutyBacktester:
                 except Exception as e: print(f"Grid Error: {e}")
 
         if not final_results: return None, None
-            
         best = sorted(final_results, key=lambda x: x['final_balance'], reverse=True)[0]
         
-        # 🔥🔥🔥 Full Report (EXACTLY AS ORIGINAL) 🔥🔥🔥
         print("\n" + "="*60)
         print(f"🏆 CHAMPION REPORT [{target_regime}]:")
-        print(f"   📅 Period: {self.force_start_date} -> {self.force_end_date}")
         print(f"   💰 Final Balance:   ${best['final_balance']:,.2f}")
-        print(f"   🚀 Net PnL:         ${best['net_profit']:,.2f}")
-        print("-" * 60)
-        print(f"   📊 Total Trades:    {best['total_trades']}")
-        print(f"   ✅ Winning Trades:  {best['win_count']}")
-        print(f"   ❌ Losing Trades:   {best['loss_count']}")
         print(f"   📈 Win Rate:        {best['win_rate']:.1f}%")
-        print("-" * 60)
-        print(f"   🟢 Max Single Win:  ${best['max_single_win']:.2f}")
-        print(f"   🔴 Max Single Loss: ${best['max_single_loss']:.2f}")
-        print(f"   🔥 Max Win Streak:  {best['max_win_streak']} trades")
-        print(f"   🧊 Max Loss Streak: {best['max_loss_streak']} trades")
-        print(f"   📉 Max Drawdown:    {best['max_drawdown']:.1f}%")
-        print("-" * 60)
         print(f"   ⚙️ Config: Titan={best['config']['w_titan']} | Struct={best['config']['w_struct']} | Thresh={best['config']['thresh']}")
         print("="*60)
-        
         return best['config'], best
 
 async def run_strategic_optimization_task():
     print("\n🧪 [STRATEGIC BACKTEST] Time Lord Initiated (Parallel Turbo)...")
-    
-    # لا نقوم بتهيئة الـ dm/proc هنا بشكل كامل، لأن العمال (Workers) سيقومون بذلك
-    # ولكن نحتاج لتمريرهم للكائن لغرض الهيكلة فقط
     r2 = R2Service()
     dm = DataManager(None, None, r2)
     proc = MLProcessor(dm)
-    
-    # لن نشغل تهيئة الـ dm هنا لأننا سنعتمد على العمال، لكن نحتاج لتهيئة r2 للـ hub
-    
     try:
         hub = AdaptiveHub(r2)
         await hub.initialize()
-        
         scenarios = [
             {"regime": "BULL", "start": "2024-01-01", "end": "2024-03-30"},
             {"regime": "BEAR", "start": "2023-08-01", "end": "2023-09-15"},
             {"regime": "DEAD", "start": "2023-06-01", "end": "2023-08-01"},
             {"regime": "RANGE", "start": "2024-07-01", "end": "2024-09-30"}
         ]
-        
         optimizer = HeavyDutyBacktester(dm, proc)
-        
         for scen in scenarios:
             target = scen["regime"]
             optimizer.set_date_range(scen["start"], scen["end"])
-            
             best_config, best_stats = await optimizer.run_optimization(target_regime=target)
-            
             if best_config and best_stats:
                 hub.submit_challenger(target, best_config, best_stats)
-        
         await hub._save_state_to_r2()
         hub._inject_current_parameters()
         print(f"✅ [System] ALL DNA Updated & Saved Successfully.")
-                
     finally:
         await dm.close()
 
 if __name__ == "__main__":
-    # Windows/macOS support for multiprocessing
     import multiprocessing
     multiprocessing.freeze_support()
     asyncio.run(run_strategic_optimization_task())