Update trade_manager.py

trade_manager.py

@@ -1,4 +1,4 @@
-# trade_manager.py (V23.2 - GEM-Architect: Sniper with Order Book)
+# trade_manager.py (V23.8 - GEM-Architect: Full Integration with Sniper 60/40 & Learning Hub)
 
 import asyncio
 import uuid
@@ -10,20 +10,24 @@ 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
+        # 🧠 The Central Brain (Titan, Oracle, Sniper, Guardian)
         self.processor = processor 
         
+        # 🎓 Learning Hub (سيتم حقنه من app.py)
+        self.learning_hub = None
+        
         self.open_positions = {}
         self.watchlist = {}
         self.sentry_tasks = {}
         self.running = True
         
-        # [ 🧠 IQ Stats ]
+        # [ 🧠 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},
@@ -32,7 +36,7 @@ class TradeManager:
         
         self.execution_lock = asyncio.Lock()
         
-        print(f"🛡️ [TradeManager V23.2] Initialized (L4 OB Enabled).")
+        print(f"🛡️ [TradeManager V23.8] Initialized (Sniper 60/40 & Learning Ready).")
 
     async def initialize_sentry_exchanges(self):
         print("🛡️ [TradeManager] Syncing state with R2...")
@@ -48,13 +52,20 @@ class TradeManager:
             self.open_positions = {} 
 
     # ==============================================================================
-    # 🎯 L4 Sniper Logic (Fusion: ML + Order Book)
+    # 🎯 L4 Sniper Logic (Fusion: ML + Order Book 60/40)
     # ==============================================================================
     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()
 
@@ -66,76 +77,78 @@ 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 candle data).")
+                print(f"   -> [L4 Skip] {symbol} (Not enough 1m candles).")
                 continue
             
-            if not order_book or 'bids' not in order_book or not order_book['bids']:
-                print(f"   -> [L4 Skip] {symbol} (Empty Order Book).")
-                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) # هذه هي الدرجة الموزونة النهائية
+            
             if sniper_result['signal'] == 'BUY':
-                confidence = sniper_result['confidence_prob']
-                # تحليل دفتر الطلبات المرفق
-                ob_info = sniper_result.get('ob_data', {})
-                ob_reason = ob_info.get('reason', 'N/A')
-                
-                print(f"   -> [L4 PASS] {symbol} (Conf: {confidence:.2f} | OB: {ob_reason})")
+                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} ({sniper_result.get('reason')})")
+                # طباعة سبب الرفض (سيوضح ما إذا كان السبب هو النموذج أو الدفتر)
+                print(f"   -> 🔴 [L4 REJECT] {symbol} | {reason_str}")
 
         if not sniper_candidates:
-            print("   -> [L4 Result] No candidates passed the Sniper & OrderBook check.")
+            print("   -> [L4 Result] No candidates passed the Sniper (60/40) check.")
             return
 
-        # ترتيب النتائج حسب الثقة
+        # ترتيب النتائج حسب الدرجة النهائية (الأعلى ثقة)
         sniper_candidates.sort(key=lambda x: (x['sniper_confidence'], x['final_total_score']), reverse=True)
         best_signal = sniper_candidates[0]
         
         print(f"   🔥 [L4 WINNER] {best_signal['symbol']} selected for execution.")
         
-        # التنفيذ
+        # التنفيذ الفعلي
         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)
+            # الأهداف (من Oracle أو حساب تلقائي)
             tp_price = float(signal_data.get('tp_price') or 0.0)
             sl_price = float(signal_data.get('sl_price') or 0.0)
 
-            # حماية ضد القيم الصفرية
             if tp_price <= 0 or sl_price <= 0:
                 atr_mock = current_price * 0.02 
                 tp_price = current_price + (atr_mock * 2.0)
                 sl_price = current_price - (atr_mock * 1.0)
 
+            # بناء كائن الصفقة
             new_trade = {
                 'id': trade_id,
                 'symbol': symbol,
@@ -146,23 +159,30 @@ class TradeManager:
                 'sl_price': sl_price,
                 'last_update': datetime.now().isoformat(),
                 
+                # تخزين البيانات الوصفية للتعلم لاحقاً
+                'strategy': 'Hybrid_Titan_V1', 
                 'l1_score': float(signal_data.get('final_total_score', 0.0)), 
                 'l2_sniper_confidence': float(l2_result.get('confidence_prob', 0.0)),
-                'l3_oracle_tp': tp_price,
-                'l3_oracle_sl': sl_price,
+                'decision_data': { # بيانات مفصلة لمركز التعلم
+                    'components': signal_data.get('components', {}),
+                    'sniper_analysis': l2_result,
+                    'oracle_tp': tp_price,
+                    'oracle_sl': sl_price
+                }
             }
             
+            # الحفظ والتحديث
             self.open_positions[symbol] = new_trade
             if self.watchlist: self.watchlist.clear()
             
-            # حفظ في R2
+            # 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))
             
@@ -173,7 +193,7 @@ class TradeManager:
             traceback.print_exc()
 
     # ==============================================================================
-    # 🛡️ Hybrid Sentry (Via Processor)
+    # 🛡️ Hybrid Sentry (حارس الخروج)
     # ==============================================================================
     async def _guardian_loop(self, symbol: str):
         print(f"🛡️ [Sentry] Guarding {symbol}...")
@@ -181,7 +201,7 @@ 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 
@@ -189,7 +209,7 @@ class TradeManager:
                 current_price = await self.data_manager.get_latest_price_async(symbol)
                 if current_price == 0.0: continue 
 
-                # 1. Hard Limits Check
+                # 1. الفحص الصارم للأهداف (Hard Limits) - الأولوية القصوى
                 if current_price >= trade['tp_price']:
                     async with self.execution_lock:
                         await self._execute_exit(symbol, current_price, "TP_HIT_HARD")
@@ -199,8 +219,9 @@ class TradeManager:
                         await self._execute_exit(symbol, current_price, "SL_HIT_HARD")
                     break 
 
-                # 2. AI Check (Every 60s)
+                # 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)
@@ -208,7 +229,7 @@ class TradeManager:
                     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')
@@ -230,10 +251,11 @@ class TradeManager:
                 await asyncio.sleep(5)
 
     # ==============================================================================
-    # 👻 Ghost Monitor & Stats
+    # 👻 Ghost Monitor & Learning Stats
     # ==============================================================================
-    def _launch_post_exit_analysis(self, symbol, exit_price, exit_time, position_size_usd, ai_scores=None):
-        asyncio.create_task(self._analyze_after_exit_task(symbol, exit_price, exit_time, position_size_usd, ai_scores))
+    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):
         if key not in self.ai_stats: return
@@ -244,33 +266,49 @@ class TradeManager:
         else:
             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):
-        await asyncio.sleep(900) # 15 min wait
+    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 دقيقة
         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"
             }
             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 Error] {e}")
+            print(f"⚠️ [Ghost/Learning Error] {e}")
 
     # ==============================================================================
-    # 🔴 Exit & Force Exit
+    # 🔴 Exit Logic (تنفيذ الخروج)
     # ==============================================================================
     async def _execute_exit(self, symbol, price, reason, ai_scores=None):
         if symbol not in self.open_positions: return
@@ -283,6 +321,7 @@ 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
@@ -299,14 +338,15 @@ 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}")
 
-            if "AI_" in reason:
-                self._launch_post_exit_analysis(symbol, exit_p, trade.get('exit_time'), curr_cap, ai_scores)
+            # إطلاق التحليل اللاحق (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:
                 self.sentry_tasks[symbol].cancel()
@@ -314,18 +354,21 @@ 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()