Update backtest_engine.py

backtest_engine.py

@@ -1,5 +1,5 @@
 # ============================================================
-# 🧪 backtest_engine.py (V90.0 - GEM-Architect: Priority Sorting Fix)
+# 🧪 backtest_engine.py (V91.0 - GEM-Architect: Sync & Math Fix)
 # ============================================================
 
 import asyncio
@@ -36,7 +36,7 @@ class HeavyDutyBacktester:
         self.TRADING_FEES = 0.001 
         self.MAX_SLOTS = 4         
         
-        # القائمة الكاملة (50 عملة)
+        # القائمة الكاملة
         self.TARGET_COINS = [
             'SOL/USDT', 'XRP/USDT', 'DOGE/USDT', 'NEAR/USDT','SHIB/USDT'
         ]
@@ -45,7 +45,7 @@ class HeavyDutyBacktester:
         self.force_end_date = None   
         
         if not os.path.exists(CACHE_DIR): os.makedirs(CACHE_DIR)
-        print(f"🧪 [Backtest V90.0] Sniper Priority Logic (Rank-Based Allocation).")
+        print(f"🧪 [Backtest V91.0] Synchronized Engine (Math Bug Fixed).")
 
     def set_date_range(self, start_str, end_str):
         self.force_start_date = start_str
@@ -124,7 +124,8 @@ class HeavyDutyBacktester:
         frames = {}
         agg_dict = {'open': 'first', 'high': 'max', 'low': 'min', 'close': 'last', 'volume': 'sum'}
         frames['1m'] = df_1m.copy()
-        frames['1m']['timestamp'] = frames['1m'].index.astype(np.int64) // 10**6
+        # تقريب التوقيت للدقيقة لضمان التزامن لاحقاً
+        frames['1m']['timestamp'] = frames['1m'].index.floor('1min').astype(np.int64) // 10**6
 
         for tf_str, tf_code in [('5m', '5T'), ('15m', '15T'), ('1h', '1h'), ('4h', '4h'), ('1d', '1D')]:
             frames[tf_str] = df_1m.resample(tf_code).agg(agg_dict).dropna()
@@ -174,8 +175,11 @@ class HeavyDutyBacktester:
                     if proc_res: real_titan = proc_res.get('titan_score', 0.5)
                 except: pass
 
+                # ✅ حفظ timestamp بوحدة الدقيقة الموحدة لضمان التزامن
+                ts_aligned = int(t_idx.timestamp() // 60) * 60 * 1000
+                
                 ai_results.append({
-                    'timestamp': int(t_idx.timestamp() * 1000),
+                    'timestamp': ts_aligned,
                     'symbol': sym,
                     'close': current_price,
                     'real_titan': real_titan, 
@@ -212,26 +216,39 @@ class HeavyDutyBacktester:
                 if candles:
                     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)
+                    print(f"   ❌ Failed/Empty data for {sym}.", flush=True)
             except Exception as e:
-                print(f"   ❌ SKIP: Error processing {sym}: {e}", flush=True)
+                print(f"   ❌ SKIP {sym}: {e}", flush=True)
                 continue
             gc.collect()
 
     # ==============================================================
-    # PHASE 2: Portfolio Digital Twin Engine (✅ FIX: Priority Sorting)
+    # PHASE 2: Portfolio Digital Twin Engine (✅ FIX: MATH & SYNC)
     # ==============================================================
     @staticmethod
     def _worker_optimize(combinations_batch, scores_files, initial_capital, fees_pct, max_slots):
         results = []
         all_data = []
+        
+        # 1. Load 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).drop_duplicates(subset=['timestamp']).sort_values('timestamp')
+        
+        # 2. Merge and Align
+        global_df = pd.concat(all_data)
+        
+        # ✅ FIX: Pivot Data for Perfect Alignment (Time x Symbol)
+        # نحتاج هيكلة تسمح لنا بمعرفة سعر كل العملات في كل دقيقة حتى لو لم يكن هناك إشارة
+        # ملاحظة: ملفات scores تحتوي فقط على الإشارات. لإدارة الخروج نحتاج أسعار مستمرة.
+        # الحل الوسط: نستخدم أسعار الإشارات المتاحة، ونفترض ثبات السعر (Forward Fill) عند الفجوات البسيطة
+        # أو نعتمد على أن الإشارة تتكرر.
+        # الأفضل: التجميع الزمني الموحد.
+        
+        global_df.sort_values('timestamp', inplace=True)
         grouped_by_time = global_df.groupby('timestamp')
         
         for config in combinations_batch:
@@ -241,36 +258,51 @@ 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()}
                 
                 # --- 1. Exit Logic ---
+                # ✅ FIX: Handle missing prices (Partial Sync)
+                # إذا العملة المفتوحة غير موجودة في بيانات هذه الدقيقة (لأنها لم تعط إشارة)،
+                # لا يمكننا فحص الخروج. ننتظر الدقيقة التالية التي تظهر فيها.
+                
                 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
-                            net_pnl = gross_pnl - fees
+                            net_pnl = gross_pnl - fees # هذا هو الربح/الخسارة الصافي
+                            
                             wallet["allocated"] -= pos['size_usd']
-                            wallet["balance"] += net_pnl
+                            
+                            # 🔥🔥 FATAL MATH BUG FIXED HERE 🔥🔥
+                            # القديم: wallet["balance"] += net_pnl (كارثة!)
+                            # الجديد: نرجع رأس المال + الربح
+                            return_amount = pos['size_usd'] + net_pnl
+                            wallet["balance"] += return_amount
+                            
                             del wallet["positions"][sym]
                             wallet["trades_history"].append({'pnl': net_pnl})
                 
+                # --- Update Stats ---
                 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) ---
+                # --- 2. Entry Logic (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:
-                        # 1. تجميع كل الفرص المتاحة في هذه الدقيقة
                         candidates = []
                         for _, row in group.iterrows():
                             sym = row['symbol']
@@ -289,24 +321,24 @@ class HeavyDutyBacktester:
                                 score = ((real_titan * w_titan) + (norm_struct * w_struct)) / (w_titan + w_struct)
                             
                             if score >= entry_thresh:
-                                # إضافة السكور للقائمة للترتيب لاحقاً
                                 candidates.append({
                                     'symbol': sym,
                                     'score': score,
                                     'price': row['close']
                                 })
                         
-                        # 2. ترتيب الفرص تنازلياً حسب القوة (الأقوى أولاً)
-                        # هذا يضمن أن العملة الأقوى (مثل SOL) تأخذ المكان قبل العملة الأضعف
+                        # ترتيب حسب القوة (Sniper Mode)
                         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
+                            curr_slots_open = len(wallet["positions"])
+                            curr_slots_left = max_slots - curr_slots_open
+                            
+                            # إذا الرصيد قليل، نوزع المتبقي على الخانات المتبقية بالتساوي
+                            if wallet["balance"] < 20.0 and curr_slots_left > 0:
+                                position_size = wallet["balance"] / curr_slots_left
                             
                             position_size = min(position_size, wallet["balance"])
                             
@@ -319,7 +351,12 @@ class HeavyDutyBacktester:
 
             trades = wallet["trades_history"]
             if trades:
-                net_profit = wallet["balance"] - initial_capital + wallet["allocated"]
+                # حساب الرصيد النهائي الصحيح
+                # ملاحظة: allocated هنا يجب أن يكون صفراً إذا أغلقت كل الصفقات
+                # أو يمثل قيمة الدخول للصفقات المفتوحة
+                final_equity = wallet["balance"] + wallet["allocated"]
+                net_profit = final_equity - initial_capital
+                
                 pnls = [t['pnl'] for t in trades]
                 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
@@ -334,7 +371,7 @@ class HeavyDutyBacktester:
                         current_loss_streak += 1; current_win_streak = 0
                         if current_loss_streak > max_loss_streak: max_loss_streak = current_loss_streak
                 results.append({
-                    'config': config, 'final_balance': wallet["balance"] + wallet["allocated"],
+                    'config': config, 'final_balance': final_equity,
                     '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,