Update backtest_engine.py

backtest_engine.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🧪 backtest_engine.py (V89.0 - GEM-Architect: Mass-Scale Edition)
+# 🧪 backtest_engine.py (V90.0 - GEM-Architect: Priority Sorting Fix)
 # ============================================================
 
 import asyncio
@@ -36,24 +36,15 @@ class HeavyDutyBacktester:
         self.TRADING_FEES = 0.001 
         self.MAX_SLOTS = 4         
         
-        # ✅ القائمة الكاملة (50 عملة)
+        # القائمة الكاملة (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'
-        ]
+            'SOL/USDT', 'XRP/USDT', 'DOGE/USDT, 'NEAR/USDT','SHIB/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 V89.0] Mass-Scale Edition (50+ Coins | Fault Tolerant).")
+        print(f"🧪 [Backtest V90.0] Sniper Priority Logic (Rank-Based Allocation).")
 
     def set_date_range(self, start_str, end_str):
         self.force_start_date = start_str
@@ -64,33 +55,29 @@ class HeavyDutyBacktester:
         return df[['timestamp', 'open', 'high', 'low', 'close', 'volume']].values.tolist()
 
     # ==============================================================
-    # ⚡ FAST DATA DOWNLOADER (Silent Burst)
+    # ⚡ FAST DATA DOWNLOADER
     # ==============================================================
     async def _fetch_all_data_fast(self, sym, start_ms, end_ms):
         print(f"   ⚡ [Network] Downloading {sym}...", flush=True)
-        
         limit = 1000
         duration_per_batch = limit * 60 * 1000
-        
         tasks = []
         current = start_ms
         while current < end_ms:
             tasks.append(current)
             current += duration_per_batch
-            
         all_candles = []
-        sem = asyncio.Semaphore(10) # 10 اتصالات متزامنة
+        sem = asyncio.Semaphore(10) 
 
         async def _fetch_batch(timestamp):
             async with sem:
-                for _ in range(3): # 3 محاولات
+                for _ in range(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]
@@ -98,12 +85,8 @@ class HeavyDutyBacktester:
             results = await asyncio.gather(*futures)
             for res in results:
                 if res: all_candles.extend(res)
-            
-            # 🚫 تم حذف طباعة النسبة المئوية حسب الطلب
 
         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 = []
@@ -111,13 +94,12 @@ class HeavyDutyBacktester:
             if c[0] not in seen:
                 unique_candles.append(c)
                 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 & Silent)
+    # 🧠 CPU PROCESSING
     # ==============================================================
     async def _process_data_in_memory(self, sym, candles, start_ms, end_ms):
         safe_sym = sym.replace('/', '_')
@@ -148,13 +130,9 @@ class HeavyDutyBacktester:
             frames[tf_str]['timestamp'] = frames[tf_str].index.astype(np.int64) // 10**6
 
         ai_results = []
-        
-        # نبدأ التحليل بعد فترة التحمية
         start_analysis_dt = df_1m.index[0] + pd.Timedelta(minutes=500)
         valid_indices = frames['5m'].loc[start_analysis_dt:].index 
         
-        # 🚫 تم حذف حلقة طباعة التقدم %
-        
         for t_idx in valid_indices:
             ohlcv_data = {}
             try:
@@ -215,7 +193,7 @@ class HeavyDutyBacktester:
         gc.collect()
 
     # ==============================================================
-    # PHASE 1: Main Loop (Fault Tolerant)
+    # PHASE 1: Main Loop
     # ==============================================================
     async def generate_truth_data(self):
         if self.force_start_date and self.force_end_date:
@@ -228,28 +206,19 @@ class HeavyDutyBacktester:
             return 
         
         for sym in self.TARGET_COINS:
-            # 🛡️ حماية شاملة: لن يتوقف السكربت أبداً بسبب عملة واحدة
             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 (Full Stats Restored)
+    # PHASE 2: Portfolio Digital Twin Engine (✅ FIX: Priority Sorting)
     # ==============================================================
     @staticmethod
     def _worker_optimize(combinations_batch, scores_files, initial_capital, fees_pct, max_slots):
@@ -272,7 +241,8 @@ class HeavyDutyBacktester:
             for ts, group in grouped_by_time:
                 active_symbols = list(wallet["positions"].keys())
                 current_prices = {row['symbol']: row['close'] for _, row in group.iterrows()}
-                # Exits
+                
+                # --- 1. Exit Logic ---
                 for sym in active_symbols:
                     if sym in current_prices:
                         curr_p = current_prices[sym]
@@ -287,36 +257,63 @@ class HeavyDutyBacktester:
                             wallet["balance"] += net_pnl
                             del wallet["positions"][sym]
                             wallet["trades_history"].append({'pnl': net_pnl})
-                # 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
 
+                # --- 2. Entry Logic (✅ REFACTORED FOR SNIPER PRIORITY) ---
                 if len(wallet["positions"]) < max_slots:
                     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)
+                        # 1. تجميع كل الفرص المتاحة في هذه الدقيقة
+                        candidates = []
                         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}
+                                # إضافة السكور للقائمة للترتيب لاحقاً
+                                candidates.append({
+                                    'symbol': sym,
+                                    'score': score,
+                                    'price': row['close']
+                                })
+                        
+                        # 2. ترتيب الفرص تنازلياً حسب القوة (الأقوى أولاً)
+                        # هذا يضمن أن العملة الأقوى (مثل SOL) تأخذ المكان قبل العملة الأضعف
+                        candidates.sort(key=lambda x: x['score'], reverse=True)
+                        
+                        # 3. تنفيذ أفضل الفرص فقط حسب الخانات المتاحة
+                        for cand in candidates[:slots_left]:
+                            position_size = wallet["balance"] / max_slots
+                            # تعديل لحالات الرصيد المنخفض
+                            current_slots_left = max_slots - len(wallet["positions"])
+                            if wallet["balance"] < 20.0 and current_slots_left > 0:
+                                position_size = wallet["balance"] / current_slots_left
+                            
+                            position_size = min(position_size, wallet["balance"])
+                            
+                            if position_size > 2.0:
+                                wallet["positions"][cand['symbol']] = {'entry_price': cand['price'], '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"]
@@ -390,7 +387,6 @@ 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}")