Update backtest_engine.py

backtest_engine.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🧪 backtest_engine.py (V88.1 - GEM-Architect: RAM-Burst Fix)
+# 🧪 backtest_engine.py (V89.0 - GEM-Architect: Mass-Scale Edition)
 # ============================================================
 
 import asyncio
@@ -35,12 +35,25 @@ class HeavyDutyBacktester:
         self.INITIAL_CAPITAL = 10.0
         self.TRADING_FEES = 0.001 
         self.MAX_SLOTS = 4         
-        self.TARGET_COINS = ['SOL/USDT']
+        
+        # ✅ القائمة الكاملة (50 عملة)
+        self.TARGET_COINS = [
+            'SOL/USDT', 'XRP/USDT', 'DOGE/USDT', 'ADA/USDT', 'AVAX/USDT', 'LINK/USDT', 
+            'TON/USDT', 'INJ/USDT', 'APT/USDT', 'OP/USDT', 'ARB/USDT', 'SUI/USDT', 
+            'SEI/USDT', 'TIA/USDT', 'MATIC/USDT', 'NEAR/USDT', 'RUNE/USDT', 'PYTH/USDT', 
+            'WIF/USDT', 'PEPE/USDT', 'SHIB/USDT', 'TRX/USDT', 'DOT/USDT', 'UNI/USDT', 
+            'ONDO/USDT', 'ENA/USDT', 'HBAR/USDT', 'XLM/USDT', 'TAO/USDT', 'ZK/USDT', 
+            'ZRO/USDT', 'KCS/USDT', 'ICP/USDT', 'SAND/USDT', 'AXS/USDT', 'APE/USDT', 
+            'GMT/USDT', 'CHZ/USDT', 'CFX/USDT', 'LDO/USDT', 'FET/USDT', 'JTO/USDT', 
+            'STRK/USDT', 'BLUR/USDT', 'ALT/USDT', 'JUP/USDT', 'PENDLE/USDT', 'ETHFI/USDT', 
+            'MEME/USDT', 'ATOM/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 V88.1] RAM-Burst Edition (Fix Applied).")
+        print(f"🧪 [Backtest V89.0] Mass-Scale Edition (50+ Coins | Fault Tolerant).")
 
     def set_date_range(self, start_str, end_str):
         self.force_start_date = start_str
@@ -51,10 +64,10 @@ class HeavyDutyBacktester:
         return df[['timestamp', 'open', 'high', 'low', 'close', 'volume']].values.tolist()
 
     # ==============================================================
-    # ⚡ FAST DATA DOWNLOADER (Async Burst)
+    # ⚡ FAST DATA DOWNLOADER (Silent Burst)
     # ==============================================================
     async def _fetch_all_data_fast(self, sym, start_ms, end_ms):
-        print(f"   ⚡ [Network] Burst-Downloading {sym} ({start_ms} -> {end_ms})...", flush=True)
+        print(f"   ⚡ [Network] Downloading {sym}...", flush=True)
         
         limit = 1000
         duration_per_batch = limit * 60 * 1000
@@ -66,32 +79,31 @@ class HeavyDutyBacktester:
             current += duration_per_batch
             
         all_candles = []
-        total_batches = len(tasks)
-        sem = asyncio.Semaphore(10) 
+        sem = asyncio.Semaphore(10) # 10 اتصالات متزامنة
 
         async def _fetch_batch(timestamp):
             async with sem:
-                for _ in range(3):
+                for _ in range(3): # 3 محاولات
                     try:
                         return await self.dm.exchange.fetch_ohlcv(sym, '1m', since=timestamp, limit=limit)
                     except Exception:
                         await asyncio.sleep(1)
                 return []
 
+        # تقسيم المهام وتشغيلها
         chunk_size = 20
         for i in range(0, len(tasks), chunk_size):
             chunk_tasks = tasks[i:i + chunk_size]
             futures = [_fetch_batch(ts) for ts in chunk_tasks]
             results = await asyncio.gather(*futures)
-            
             for res in results:
                 if res: all_candles.extend(res)
             
-            progress = min(100, int((i + chunk_size) / total_batches * 100))
-            print(f"     📥 Downloaded {progress}%... (Total: {len(all_candles)} candles)", flush=True)
+            # 🚫 تم حذف طباعة النسبة المئوية حسب الطلب
 
         if not all_candles: return None
         
+        # تنظيف البيانات
         filtered = [c for c in all_candles if c[0] >= start_ms and c[0] <= end_ms]
         seen = set()
         unique_candles = []
@@ -101,14 +113,14 @@ class HeavyDutyBacktester:
                 seen.add(c[0])
         
         unique_candles.sort(key=lambda x: x[0])
+        print(f"     ✅ Downloaded {len(unique_candles)} candles for {sym}.", flush=True)
         return unique_candles
 
     # ==============================================================
-    # 🧠 CPU PROCESSING (In-Memory)
+    # 🧠 CPU PROCESSING (In-Memory & Silent)
     # ==============================================================
     async def _process_data_in_memory(self, sym, candles, start_ms, end_ms):
         safe_sym = sym.replace('/', '_')
-        # ✅ FIX: Use passed arguments directly
         period_suffix = f"{start_ms}_{end_ms}"
         scores_file = f"{CACHE_DIR}/{safe_sym}_{period_suffix}_scores.pkl"
 
@@ -116,7 +128,7 @@ class HeavyDutyBacktester:
              print(f"   📂 [{sym}] Data Exists -> Skipping.")
              return
 
-        print(f"   ⚙️ [CPU] Processing {len(candles)} candles from RAM...", flush=True)
+        print(f"   ⚙️ [CPU] Processing {sym}...", flush=True)
         t0 = time.time()
 
         df_1m = pd.DataFrame(candles, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
@@ -137,18 +149,13 @@ class HeavyDutyBacktester:
 
         ai_results = []
         
+        # نبدأ التحليل بعد فترة التحمية
         start_analysis_dt = df_1m.index[0] + pd.Timedelta(minutes=500)
         valid_indices = frames['5m'].loc[start_analysis_dt:].index 
         
-        total_steps = len(valid_indices)
-        step_count = 0
+        # 🚫 تم حذف حلقة طباعة التقدم %
         
         for t_idx in valid_indices:
-            step_count += 1
-            if step_count % 2000 == 0:
-                 pct = int((step_count / total_steps) * 100)
-                 print(f"     🧠 AI Analysis: {pct}%...", flush=True)
-
             ohlcv_data = {}
             try:
                 cutoff = t_idx
@@ -200,15 +207,15 @@ class HeavyDutyBacktester:
         dt = time.time() - t0
         if ai_results:
             pd.DataFrame(ai_results).to_pickle(scores_file)
-            print(f"   💾 [{sym}] Saved {len(ai_results)} signals. (Compute Time: {dt:.1f}s)")
+            print(f"   💾 [{sym}] Saved {len(ai_results)} signals. (Processed in {dt:.1f}s)", flush=True)
         else:
-            print(f"   ⚠️ [{sym}] No signals found.")
+            print(f"   ⚠️ [{sym}] No signals found.", flush=True)
             
         del frames, df_1m, candles
         gc.collect()
 
     # ==============================================================
-    # PHASE 1: Main Loop
+    # PHASE 1: Main Loop (Fault Tolerant)
     # ==============================================================
     async def generate_truth_data(self):
         if self.force_start_date and self.force_end_date:
@@ -216,24 +223,33 @@ class HeavyDutyBacktester:
             dt_end = datetime.strptime(self.force_end_date, "%Y-%m-%d").replace(tzinfo=timezone.utc)
             start_time_ms = int(dt_start.timestamp() * 1000)
             end_time_ms = int(dt_end.timestamp() * 1000)
-            print(f"\n🚜 [Phase 1] Era: {self.force_start_date} -> {self.force_end_date}")
+            print(f"\n🚜 [Phase 1] Processing Era: {self.force_start_date} -> {self.force_end_date}")
         else:
             return 
         
         for sym in self.TARGET_COINS:
-            # 1. Download Phase (Async Burst)
-            candles = await self._fetch_all_data_fast(sym, start_time_ms, end_time_ms)
-            
-            if candles:
-                # 2. Processing Phase (Sequential CPU)
-                await self._process_data_in_memory(sym, candles, start_time_ms, end_time_ms)
-            else:
-                print(f"   ❌ Failed to download data for {sym}")
-
+            # 🛡️ حماية شاملة: لن يتوقف السكربت أبداً بسبب عملة واحدة
+            try:
+                # 1. Download Phase
+                candles = await self._fetch_all_data_fast(sym, start_time_ms, end_time_ms)
+                
+                if candles:
+                    # 2. Processing Phase
+                    await self._process_data_in_memory(sym, candles, start_time_ms, end_time_ms)
+                else:
+                    print(f"   ❌ Failed/Empty data for {sym}. Continuing...", flush=True)
+
+            except Exception as e:
+                # طباعة الخطأ والمتابعة فوراً
+                print(f"   ❌ SKIP: Error processing {sym}: {e}", flush=True)
+                # traceback.print_exc() # يمكنك تفعيلها إذا أردت التفاصيل
+                continue
+
+            # تنظيف إضافي بعد كل عملة
             gc.collect()
 
     # ==============================================================
-    # PHASE 2: Portfolio Digital Twin Engine
+    # PHASE 2: Portfolio Digital Twin Engine (Full Stats Restored)
     # ==============================================================
     @staticmethod
     def _worker_optimize(combinations_batch, scores_files, initial_capital, fees_pct, max_slots):
@@ -374,16 +390,30 @@ class HeavyDutyBacktester:
         if not final_results: return None, None
         best = sorted(final_results, key=lambda x: x['final_balance'], reverse=True)[0]
         
+        # ✅ الطباعة الكاملة للإحصائيات (كما في الملف الأصلي)
         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] RAM-Burst Mode Initiated...")
+    print("\n🧪 [STRATEGIC BACKTEST] Mass-Scale Edition Initiated...")
     r2 = R2Service()
     dm = DataManager(None, None, r2)
     proc = MLProcessor(dm)