Update trade_manager.py

trade_manager.py

@@ -1,4 +1,4 @@
-# trade_manager.py (V23.8 - GEM-Architect: Full Integration with Sniper 60/40 & Learning Hub)
+# trade_manager.py (V23.9 - GEM-Architect: KeyError Fix)
 
 import asyncio
 import uuid
@@ -9,17 +9,9 @@ from typing import List, Dict, Any
 
 class TradeManager:
     def __init__(self, r2_service, data_manager, processor): 
-        """
-        مدير الصفقات: المسؤول التنفيذي.
-        ينسق بين البيانات (Data)، العقل (Processor)، ومركز التعلم (Learning Hub).
-        """
         self.r2 = r2_service
         self.data_manager = data_manager
-        
-        # 🧠 The Central Brain (Titan, Oracle, Sniper, Guardian)
         self.processor = processor 
-        
-        # 🎓 Learning Hub (سيتم حقنه من app.py)
         self.learning_hub = None
         
         self.open_positions = {}
@@ -27,7 +19,6 @@ class TradeManager:
         self.sentry_tasks = {}
         self.running = True
         
-        # [ 🧠 IQ Stats ] إحصائيات الذكاء الاصطناعي للواجهة
         self.ai_stats = {
             "hybrid": {"total": 0, "good": 0, "saved": 0.0, "missed": 0.0},
             "v2":     {"total": 0, "good": 0, "saved": 0.0, "missed": 0.0},
@@ -35,8 +26,7 @@ class TradeManager:
         }
         
         self.execution_lock = asyncio.Lock()
-        
-        print(f"🛡️ [TradeManager V23.8] Initialized (Sniper 60/40 & Learning Ready).")
+        print(f"🛡️ [TradeManager V23.9] Initialized (KeyError Fixed).")
 
     async def initialize_sentry_exchanges(self):
         print("🛡️ [TradeManager] Syncing state with R2...")
@@ -52,20 +42,13 @@ class TradeManager:
             self.open_positions = {} 
 
     # ==============================================================================
-    # 🎯 L4 Sniper Logic (Fusion: ML + Order Book 60/40)
+    # 🎯 L4 Sniper Logic
     # ==============================================================================
     async def select_and_execute_best_signal(self, oracle_approved_signals: List[Dict[str, Any]]):
-        """
-        مرحلة الفرز النهائي (القناص):
-        - تجلب شموع الدقيقة + دفتر الطلبات.
-        - ترسلها للمعالج ليطبق معادلة (0.6*ML + 0.4*OB).
-        - تختار الأفضل وتنفذه.
-        """
         if len(self.open_positions) > 0:
              print(f"⛔ [TradeManager] Scan aborted. Max positions reached.")
              return
 
-        # التأكد من جاهزية المعالج
         if not self.processor.initialized:
             await self.processor.initialize()
 
@@ -77,69 +60,57 @@ class TradeManager:
             if symbol in self.open_positions or symbol in self.watchlist:
                 continue
 
-            # ⚡ [Parallel Fetch] جلب الشموع + دفتر الطلبات معاً للسرعة ⚡
+            # جلب البيانات (Parallel Fetch)
             ohlcv_task = self.data_manager.get_latest_ohlcv(symbol, '1m', 600)
             ob_task = self.data_manager.get_order_book_snapshot(symbol)
-            
             ohlcv_1m, order_book = await asyncio.gather(ohlcv_task, ob_task)
             
-            # التحقق من سلامة البيانات
             if not ohlcv_1m or len(ohlcv_1m) < 500:
-                print(f"   -> [L4 Skip] {symbol} (Not enough 1m candles).")
+                print(f"   -> [L4 Skip] {symbol} (Not enough data).")
                 continue
             
-            # دفتر الطلبات فارغ؟ (نكمل ولكن الدرجة ستتأثر)
-            if not order_book:
-                print(f"   ⚠️ [L4 Warn] {symbol} (Empty Order Book). Proceeding with ML only...")
-
-            # ⚡ استشارة القناص (Processor -> SniperEngine) ⚡
+            # استشارة القناص
             sniper_result = await self.processor.check_sniper_entry(ohlcv_1m, order_book)
             
-            # استخراج بيانات التقرير
             reason_str = sniper_result.get('reason', 'N/A')
-            confidence = sniper_result.get('confidence_prob', 0.0) # هذه هي الدرجة الموزونة النهائية
+            confidence = sniper_result.get('confidence_prob', 0.0)
             
             if sniper_result['signal'] == 'BUY':
                 print(f"   -> 🟢 [L4 PASS] {symbol} | Score: {confidence:.2f} | {reason_str}")
-                
                 signal['l2_sniper_result'] = sniper_result
                 signal['sniper_confidence'] = confidence
                 sniper_candidates.append(signal)
             else:
-                # طباعة سبب الرفض (سيوضح ما إذا كان السبب هو النموذج أو الدفتر)
                 print(f"   -> 🔴 [L4 REJECT] {symbol} | {reason_str}")
 
         if not sniper_candidates:
-            print("   -> [L4 Result] No candidates passed the Sniper (60/40) check.")
+            print("   -> [L4 Result] No candidates passed the Sniper check.")
             return
 
-        # ترتيب النتائج حسب الدرجة النهائية (الأعلى ثقة)
-        sniper_candidates.sort(key=lambda x: (x['sniper_confidence'], x['final_total_score']), reverse=True)
-        best_signal = sniper_candidates[0]
+        # ✅ [FIXED HERE] استخدام الاسم الصحيح 'enhanced_final_score' واستخدام .get للحماية
+        sniper_candidates.sort(
+            key=lambda x: (x.get('sniper_confidence', 0), x.get('enhanced_final_score', 0)), 
+            reverse=True
+        )
         
-        print(f"   🔥 [L4 WINNER] {best_signal['symbol']} selected for execution.")
+        best_signal = sniper_candidates[0]
+        print(f"   🔥 [L4 WINNER] {best_signal['symbol']} selected.")
         
-        # التنفيذ الفعلي
         async with self.execution_lock:
             if len(self.open_positions) == 0 and best_signal['symbol'] not in self.open_positions:
                 await self._execute_entry_from_signal(best_signal['symbol'], best_signal)
 
     # ==============================================================================
-    # 🎯 Entry Execution (تنفيذ الدخول)
+    # 🎯 Entry Execution
     # ==============================================================================
     async def _execute_entry_from_signal(self, symbol, signal_data):
         try:
             trade_id = str(uuid.uuid4())
             current_price = float(signal_data.get('current_price', 0.0))
-            
-            # حماية: إذا السعر 0، اطلبه مرة أخرى
             if current_price <= 0.0:
                  current_price = await self.data_manager.get_latest_price_async(symbol)
 
-            # بيانات القناص (للتخزين)
             l2_result = signal_data.get('l2_sniper_result', {})
-            
-            # الأهداف (من Oracle أو حساب تلقائي)
             tp_price = float(signal_data.get('tp_price') or 0.0)
             sl_price = float(signal_data.get('sl_price') or 0.0)
 
@@ -148,7 +119,6 @@ class TradeManager:
                 tp_price = current_price + (atr_mock * 2.0)
                 sl_price = current_price - (atr_mock * 1.0)
 
-            # بناء كائن الصفقة
             new_trade = {
                 'id': trade_id,
                 'symbol': symbol,
@@ -158,12 +128,13 @@ class TradeManager:
                 'tp_price': tp_price,
                 'sl_price': sl_price,
                 'last_update': datetime.now().isoformat(),
-                
-                # تخزين البيانات الوصفية للتعلم لاحقاً
                 'strategy': 'Hybrid_Titan_V1', 
-                'l1_score': float(signal_data.get('final_total_score', 0.0)), 
+                
+                # ✅ [FIXED HERE] استخدام الاسم الصحيح للحفظ في السجل
+                'l1_score': float(signal_data.get('enhanced_final_score', 0.0)), 
+                
                 'l2_sniper_confidence': float(l2_result.get('confidence_prob', 0.0)),
-                'decision_data': { # بيانات مفصلة لمركز التعلم
+                'decision_data': {
                     'components': signal_data.get('components', {}),
                     'sniper_analysis': l2_result,
                     'oracle_tp': tp_price,
@@ -171,18 +142,15 @@ class TradeManager:
                 }
             }
             
-            # الحفظ والتحديث
             self.open_positions[symbol] = new_trade
             if self.watchlist: self.watchlist.clear()
             
-            # R2 Update
             portfolio = await self.r2.get_portfolio_state_async()
             if portfolio.get('first_trade_timestamp') is None:
                 portfolio['first_trade_timestamp'] = new_trade['entry_time']
                 await self.r2.save_portfolio_state_async(portfolio)
             await self.r2.save_open_trades_async(list(self.open_positions.values()))
             
-            # تشغيل الحارس
             if symbol in self.sentry_tasks: self.sentry_tasks[symbol].cancel()
             self.sentry_tasks[symbol] = asyncio.create_task(self._guardian_loop(symbol))
             
@@ -193,7 +161,7 @@ class TradeManager:
             traceback.print_exc()
 
     # ==============================================================================
-    # 🛡️ Hybrid Sentry (حارس الخروج)
+    # 🛡️ Hybrid Sentry
     # ==============================================================================
     async def _guardian_loop(self, symbol: str):
         print(f"🛡️ [Sentry] Guarding {symbol}...")
@@ -201,15 +169,13 @@ class TradeManager:
         
         while self.running and symbol in self.open_positions:
             try:
-                await asyncio.sleep(2) # فحص سريع كل ثانيتين
-                
+                await asyncio.sleep(2) 
                 trade = self.open_positions.get(symbol)
                 if not trade: break 
 
                 current_price = await self.data_manager.get_latest_price_async(symbol)
                 if current_price == 0.0: continue 
 
-                # 1. الفحص الصارم للأهداف (Hard Limits) - الأولوية القصوى
                 if current_price >= trade['tp_price']:
                     async with self.execution_lock:
                         await self._execute_exit(symbol, current_price, "TP_HIT_HARD")
@@ -219,19 +185,14 @@ class TradeManager:
                         await self._execute_exit(symbol, current_price, "SL_HIT_HARD")
                     break 
 
-                # 2. فحص الذكاء الاصطناعي (كل 60 ثانية)
                 if time.time() - last_ai_check_time > 60:
-                    # جلب بيانات متعددة الأطر للحارس
                     t1 = self.data_manager.get_latest_ohlcv(symbol, '1m', 300)
                     t5 = self.data_manager.get_latest_ohlcv(symbol, '5m', 200)
                     t15 = self.data_manager.get_latest_ohlcv(symbol, '15m', 100)
-                    
                     d1, d5, d15 = await asyncio.gather(t1, t5, t15)
                     
                     if d1 and d5 and d15 and len(d1) >= 200:
-                        # استشارة المعالج (الذي يستشير الحارس)
                         decision = self.processor.consult_guardian(d1, d5, d15, trade['entry_price'])
-                        
                         action = decision.get('action', 'HOLD')
                         scores = decision.get('scores', {})
                         
@@ -240,21 +201,17 @@ class TradeManager:
                             async with self.execution_lock:
                                 await self._execute_exit(symbol, current_price, f"AI_{action}", ai_scores=scores)
                             break
-                            
                     last_ai_check_time = time.time()
                     self.open_positions[symbol]['last_update'] = datetime.now().isoformat()
-            
-            except asyncio.CancelledError:
-                break
+            except asyncio.CancelledError: break
             except Exception as e:
                 print(f"❌ [Sentry Error] {symbol}: {e}")
                 await asyncio.sleep(5)
 
     # ==============================================================================
-    # 👻 Ghost Monitor & Learning Stats
+    # 👻 Ghost Monitor & Learning
     # ==============================================================================
     def _launch_post_exit_analysis(self, symbol, exit_price, exit_time, position_size_usd, ai_scores=None, trade_obj=None):
-        # تشغيل مهمة الخلفية للتعلم
         asyncio.create_task(self._analyze_after_exit_task(symbol, exit_price, exit_time, position_size_usd, ai_scores, trade_obj))
 
     def _update_specific_stat(self, key, is_good, usd_impact):
@@ -267,52 +224,35 @@ class TradeManager:
             self.ai_stats[key]["missed"] += abs(usd_impact)
 
     async def _analyze_after_exit_task(self, symbol, exit_price, exit_time, position_size_usd, ai_scores, trade_obj):
-        """
-        تحليل ما بعد الخروج:
-        1. يراقب السعر بعد 15 دقيقة (Ghost Monitor).
-        2. يرسل الصفقة لمركز التعلم (Learning Hub).
-        """
-        await asyncio.sleep(900) # انتظار 15 دقيقة
+        await asyncio.sleep(900)
         try:
             curr = await self.data_manager.get_latest_price_async(symbol)
             if curr == 0: return
 
-            # هل كان الخروج جيداً؟
-            # إذا بعنا والسعر نزل -> جيد (وفرنا خسارة)
-            # إذا بعنا والسعر صعد -> سيء (فوتنا ربح)
             change_pct = (curr - exit_price) / exit_price
             usd_impact = change_pct * position_size_usd
             is_good_exit = change_pct < 0 
             
-            # تحديث إحصائيات الواجهة
             self._update_specific_stat("hybrid", is_good_exit, usd_impact)
             if ai_scores:
                 if ai_scores.get('v2', 0) >= 0.60: self._update_specific_stat("v2", is_good_exit, usd_impact)
                 if ai_scores.get('v3', 0) >= 0.75: self._update_specific_stat("v3", is_good_exit, usd_impact)
 
-            # تسجيل التدقيق في R2
-            record = {
-                "symbol": symbol, "exit_price": exit_price, "price_15m": curr,
-                "usd_impact": usd_impact, "verdict": "SUCCESS" if is_good_exit else "MISS"
-            }
+            record = {"symbol": symbol, "exit_price": exit_price, "price_15m": curr, "usd_impact": usd_impact, "verdict": "SUCCESS" if is_good_exit else "MISS"}
             await self.r2.append_deep_steward_audit(record)
 
-            # 🎓 إرسال البيانات لمركز التعلم (The Self-Evolving Step) 🎓
             if self.learning_hub and trade_obj:
-                # نحدث كائن الصفقة بالنتيجة النهائية
                 trade_obj['pnl_percent'] = trade_obj.get('profit_pct', 0.0)
-                # نرسلها للمدير التعليمي ليوزعها (أوزان + تدريب)
                 await self.learning_hub.analyze_trade_and_learn(trade_obj, trade_obj.get('exit_reason', 'UNKNOWN'))
 
         except Exception as e:
             print(f"⚠️ [Ghost/Learning Error] {e}")
 
     # ==============================================================================
-    # 🔴 Exit Logic (تنفيذ الخروج)
+    # 🔴 Exit Logic
     # ==============================================================================
     async def _execute_exit(self, symbol, price, reason, ai_scores=None):
         if symbol not in self.open_positions: return
-
         try:
             trade = self.open_positions.pop(symbol) 
             entry = float(trade['entry_price'])
@@ -321,7 +261,6 @@ class TradeManager:
             
             trade.update({'status': 'CLOSED', 'exit_price': exit_p, 'exit_reason': reason, 'profit_pct': profit_pct*100})
 
-            # المحاسبة
             portfolio = await self.r2.get_portfolio_state_async()
             curr_cap = float(portfolio.get('current_capital_usd', 100.0))
             pnl_usd = curr_cap * profit_pct
@@ -338,14 +277,12 @@ class TradeManager:
                 portfolio['total_loss_usd'] = portfolio.get('total_loss_usd', 0) + abs(pnl_usd)
                 trade['result'] = 'LOSS'
 
-            # الحفظ
             await self.r2.save_portfolio_state_async(portfolio)
             await self.r2.save_open_trades_async(list(self.open_positions.values()))
             await self.r2.append_to_closed_trades_history(trade)
             
             print(f"✅ [EXIT] {symbol} | PnL: {trade['profit_pct']:.2f}% | Cap: ${new_cap:.2f}")
 
-            # إطلاق التحليل اللاحق (Learning & Ghost)
             self._launch_post_exit_analysis(symbol, exit_p, trade.get('exit_time'), curr_cap, ai_scores, trade)
 
             if symbol in self.sentry_tasks:
@@ -354,21 +291,18 @@ class TradeManager:
 
         except Exception as e:
             print(f"❌ [Exit Error] {e}")
-            self.open_positions[symbol] = trade # استعادة الصفقة في حال فشل الخروج
+            self.open_positions[symbol] = trade 
 
     async def force_exit_by_manager(self, symbol, reason):
-        """الخروج اليدوي القسري"""
         p = await self.data_manager.get_latest_price_async(symbol)
         async with self.execution_lock:
             await self._execute_exit(symbol, p, reason)
 
     async def start_sentry_loops(self):
-        """إعادة تشغيل المراقبة للصفقات الموجودة عند بدء النظام"""
         for symbol in list(self.open_positions.keys()):
              if symbol not in self.sentry_tasks or self.sentry_tasks[symbol].done():
                  self.sentry_tasks[symbol] = asyncio.create_task(self._guardian_loop(symbol))
 
     async def stop_sentry_loops(self):
-        """إيقاف جميع الحراس عند الإغلاق"""
         self.running = False
         for task in self.sentry_tasks.values(): task.cancel()