Update trade_manager.py

trade_manager.py

@@ -1,7 +1,8 @@
-# trade_manager.py (V22.4 - GEM-Architect: Full Logic + Multi-Stats + 300 Candle Fix)
+# trade_manager.py (V22.5 - GEM-Architect: Real-Time Hard Limits Fix)
 import asyncio
 import json
 import uuid
+import time
 import traceback
 from datetime import datetime
 from typing import List, Dict, Any
@@ -26,22 +27,18 @@ class TradeManager:
         self.sentry_tasks = {}
         self.running = True
         
-        # [ 🧠 IQ Stats ] مخزن الإحصائيات (سجلات فقط - المال في R2)
-        # Hybrid: كل الصفقات التي أغلقها الذكاء الاصطناعي
-        # V2: إحصائيات خاصة عندما كان V2 مرتفعاً
-        # V3: إحصائيات خاصة عندما كان V3 مرتفعاً
+        # [ 🧠 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},
             "v3":     {"total": 0, "good": 0, "saved": 0.0, "missed": 0.0}
         }
         
-        # للإبقاء على التوافق مع الكود القديم الذي قد يطلب ds_stats مباشرة
         self.ds_stats = self.ai_stats["hybrid"]
         
         self.execution_lock = asyncio.Lock()
         
-        print(f"🛡️ [TradeManager V22.4] Initialized. Hybrid Guardian Active (Limit: 300).")
+        print(f"🛡️ [TradeManager V22.5] Initialized. Real-Time Hard Limits Enabled.")
 
     async def initialize_sentry_exchanges(self):
         print("🛡️ [TradeManager] Initializing and syncing state with R2...")
@@ -195,14 +192,12 @@ class TradeManager:
                 self.watchlist.clear()
             
             # ============================================================
-            # 🕒 تسجيل وقت أول صفقة في تاريخ النظام (للعداد)
+            # 🕒 تسجيل وقت أول صفقة
             # ============================================================
             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)
-                print(f"🕒 [System Info] تم تسجيل توقيت أول صفقة في النظام: {new_trade['entry_time']}")
-            # ============================================================
 
             await self.r2.save_open_trades_async(list(self.open_positions.values()))
             
@@ -212,7 +207,6 @@ class TradeManager:
             self.sentry_tasks[symbol] = asyncio.create_task(self._guardian_loop(symbol))
             
             print(f"✅ [ENTRY EXECUTED] {symbol} | Price: {current_price:.8f} | TP: {tp_price:.8f} | SL: {sl_price:.8f}")
-            print(f"   -> L2 Score: {new_trade['l1_score']:.2f}, L4 Conf: {new_trade['l2_sniper_confidence']:.2f}")
 
         except Exception as e:
             print(f"❌ [TradeManager] فشل فادح أثناء تنفيذ الدخول لـ {symbol}: {e}")
@@ -266,15 +260,18 @@ class TradeManager:
             await self.select_and_execute_best_signal(signals_from_watchlist)
 
     # ==============================================================================
-    # 🛡️ دوال حارس الخروج (Hybrid Sentry)
+    # 🛡️ دوال حارس الخروج (Hybrid Sentry) - [CRITICAL FIX: Real-Time Checks]
     # ==============================================================================
     async def _guardian_loop(self, symbol: str):
-        print(f"🛡️ [Sentry Activated] بدء الحراسة لـ {symbol} (فحص كل 60 ثانية).")
+        print(f"🛡️ [Sentry Activated] بدء الحراسة لـ {symbol} (وضع الاستجابة الفورية).")
+        
+        last_ai_check_time = 0
         
         while self.running and symbol in self.open_positions:
             try:
-                # 🚀 1. الانتظار لمدة 60 ثانية
-                await asyncio.sleep(60) 
+                # ⚡ [FAST LANE] المسار السريع: فحص الحدود الصارمة كل 2 ثانية
+                # هذا يضمن عدم تفويت الهدف إذا تحرك السعر بسرعة
+                await asyncio.sleep(2) 
                 
                 trade = self.open_positions.get(symbol)
                 if not trade: break 
@@ -282,71 +279,66 @@ class TradeManager:
                 current_price = await self.data_manager.get_latest_price_async(symbol)
                 if current_price == 0.0: continue 
 
-                # 🚀 2. فحص الحدود الصارمة (Hard Limits) - أمان أخير
+                # 1. فحص الحدود الصارمة (Hard Limits) - أولوية قصوى
                 if current_price >= trade['tp_price']:
-                    print(f"✅ [Sentry EXIT] {symbol} (Hard TP Hit) at {current_price:.8f}")
+                    print(f"✅ [Sentry FAST] {symbol} (Target Hit) at {current_price:.8f}")
                     async with self.execution_lock:
                         await self._execute_exit(symbol, current_price, "TP_HIT_HARD")
                     break 
 
                 if current_price <= trade['sl_price']:
-                    print(f"🛑 [Sentry EXIT] {symbol} (Hard SL Hit) at {current_price:.8f}")
+                    print(f"🛑 [Sentry FAST] {symbol} (Stop Loss Hit) at {current_price:.8f}")
                     async with self.execution_lock:
                         await self._execute_exit(symbol, current_price, "SL_HIT_HARD")
                     break 
 
-                # 🚀 3. [ 🧠 ] Hybrid DeepSteward (V2 + V3 Dual Brain)
-                if self.deep_steward and self.deep_steward.initialized:
-                    # --- [تعديل جوهري] زيادة الحد إلى 300 شمعة لتجنب أخطاء النموذج ---
-                    task1 = self.data_manager.get_latest_ohlcv(symbol, '1m', 300)
-                    task5 = self.data_manager.get_latest_ohlcv(symbol, '5m', 200)
-                    task15 = self.data_manager.get_latest_ohlcv(symbol, '15m', 100)
-                    
-                    d1, d5, d15 = await asyncio.gather(task1, task5, task15)
-                    
-                    # التأكد من وجود بيانات كافية (V2 يحتاج 64 شمعة، المؤشرات تحتاج 200)
-                    if d1 and d5 and d15 and len(d1) >= 200:
-                        # استشارة الحارس الهجين
-                        decision = self.deep_steward.analyze_position(d1, d5, d15, trade['entry_price'])
-                        action = decision.get('action', 'HOLD')
-                        scores = decision.get('scores', {}) # درجات V2 و V3 للتدقيق
+                # 🐌 [SLOW LANE] المسار البطيء: فحص الذكاء الاصطناعي كل 60 ثانية
+                if time.time() - last_ai_check_time > 60:
+                    if self.deep_steward and self.deep_steward.initialized:
+                        # جلب البيانات اللازمة (تم تثبيت الحد على 300)
+                        task1 = self.data_manager.get_latest_ohlcv(symbol, '1m', 300)
+                        task5 = self.data_manager.get_latest_ohlcv(symbol, '5m', 200)
+                        task15 = self.data_manager.get_latest_ohlcv(symbol, '15m', 100)
                         
-                        if action == 'EXIT_HARD':
-                            print(f"🤖 [Hybrid Guardian] 🚨 خروج طارئ! {decision['reason']}")
-                            async with self.execution_lock:
-                                await self._execute_exit(symbol, current_price, "AI_HARD_EXIT", ai_scores=scores)
-                            break
+                        d1, d5, d15 = await asyncio.gather(task1, task5, task15)
                         
-                        elif action == 'EXIT_SOFT':
-                            print(f"🤖 [Hybrid Guardian] ⚠️ تحذير خروج! {decision['reason']}")
-                            # هنا يمكن إضافة منطق لتشديد الستوب بدلاً من الخروج المباشر
-                            async with self.execution_lock:
-                                await self._execute_exit(symbol, current_price, "AI_SOFT_EXIT", ai_scores=scores)
-                            break
-
-                    else:
-                        print(f"⚠️ [Sentry] بيانات الحارس الهجين غير مكتملة لـ {symbol} (Rows: {len(d1) if d1 else 0}). تخطي الدورة.")
-                else:
-                    pass # لا يوجد نموذج فعال
-
-                self.open_positions[symbol]['last_update'] = datetime.now().isoformat()
+                        if d1 and d5 and d15 and len(d1) >= 200:
+                            decision = self.deep_steward.analyze_position(d1, d5, d15, trade['entry_price'])
+                            action = decision.get('action', 'HOLD')
+                            scores = decision.get('scores', {}) 
+                            
+                            if action == 'EXIT_HARD':
+                                print(f"🤖 [Hybrid Guardian] 🚨 خروج طارئ! {decision['reason']}")
+                                async with self.execution_lock:
+                                    await self._execute_exit(symbol, current_price, "AI_HARD_EXIT", ai_scores=scores)
+                                break
+                            
+                            elif action == 'EXIT_SOFT':
+                                print(f"🤖 [Hybrid Guardian] ⚠️ تحذير خروج! {decision['reason']}")
+                                async with self.execution_lock:
+                                    await self._execute_exit(symbol, current_price, "AI_SOFT_EXIT", ai_scores=scores)
+                                break
+                        else:
+                            # لو البيانات ناقصة، ننتظر الد��رة القادمة
+                            pass
+                            
+                    last_ai_check_time = time.time()
+                    self.open_positions[symbol]['last_update'] = datetime.now().isoformat()
             
             except asyncio.CancelledError:
                 print(f"🛡️ [Sentry STOP] تم إيقاف الحارس لـ {symbol}.")
                 break
             except Exception as e:
                 print(f"❌ [Sentry ERROR] فشل مؤقت لـ {symbol}: {e}")
-                await asyncio.sleep(10) 
+                await asyncio.sleep(5) # انتظار قصير عند الخطأ
 
     # ==============================================================================
-    # 👻 المراقب الشبحي (Ghost Monitor) - [محدث لتوزيع الإحصائيات]
+    # 👻 المراقب الشبحي (Ghost Monitor)
     # ==============================================================================
     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 _update_specific_stat(self, key, is_good, usd_impact):
-        """دالة مساعدة لتحديث إحصائيات محفظة معينة (Hybrid, V2, V3)"""
         if key not in self.ai_stats: return
         self.ai_stats[key]["total"] += 1
         if is_good:
@@ -356,41 +348,36 @@ 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):
-        # ⏳ ننتظر 15 دقيقة (900 ثانية)
         await asyncio.sleep(900) 
         
         try:
             current_price = await self.data_manager.get_latest_price_async(symbol)
             if current_price == 0: return
 
-            # هل كان الخروج صحيحاً؟
             change_pct = (current_price - exit_price) / exit_price
             usd_impact = change_pct * position_size_usd
-            is_good_exit = change_pct < 0 # جيد إذا السعر هبط بعد الخروج
+            is_good_exit = change_pct < 0 
             
-            # 1. تحديث إحصائيات النظام الهجين (الكل)
+            # 1. تحديث الهجين
             self._update_specific_stat("hybrid", is_good_exit, usd_impact)
             
-            # 2. توزيع الفضل (Attribution) لـ V2 و V3
+            # 2. تحديث المكونات
             if ai_scores:
                 v2_score = ai_scores.get('v2', 0.0)
                 v3_score = ai_scores.get('v3', 0.0)
                 
-                # V2 ينسب له الفضل إذا كانت درجة الخطر لديه عالية (فتح البوابة)
-                if v2_score >= 0.60:
+                if v2_score >= 0.60: # V2 ساهم
                     self._update_specific_stat("v2", is_good_exit, usd_impact)
                 
-                # V3 ينسب له الفضل إذا كانت درجة الثقة لديه عالية (ضغط الزناد)
-                if v3_score >= 0.75:
+                if v3_score >= 0.75: # V3 ساهم
                     self._update_specific_stat("v3", is_good_exit, usd_impact)
 
-            # إعداد السجل لـ R2
             audit_record = {
                 "symbol": symbol,
                 "exit_time": exit_time,
                 "exit_price": exit_price,
-                "price_15m_later": current_price,
-                "change_15m_pct": change_pct * 100,
+                "price_15m_later": current_price, 
+                "change_15m_pct": change_pct * 100, 
                 "usd_impact": usd_impact,
                 "verdict": "SUCCESS (Saved Loss)" if is_good_exit else "MISS (Lost Profit)",
                 "ai_scores": ai_scores if ai_scores else {},
@@ -401,7 +388,7 @@ class TradeManager:
             print(f"👻 [Ghost Monitor] {symbol}: {audit_record['verdict']} | Impact: ${usd_impact:.2f}")
 
         except Exception as e:
-            print(f"⚠️ [Ghost Error] فشل تحليل ما بعد الخروج لـ {symbol}: {e}")
+            print(f"⚠️ [Ghost Error] {symbol}: {e}")
 
     # ==============================================================================
     # 🔴 دالة الخروج المحاسبية (Accounting Exit Logic)
@@ -412,31 +399,25 @@ class TradeManager:
             return
 
         try:
-            # 1. استخراج بيانات الصفقة
             trade = self.open_positions.pop(symbol) 
-            
             entry_price = float(trade['entry_price'])
             exit_price = float(price)
             
-            # 2. حساب نسبة الربح
             raw_profit_pct = (exit_price - entry_price) / entry_price
             profit_pct_display = raw_profit_pct * 100
             
-            # 3. تحديث بيانات الصفقة
             trade['status'] = 'CLOSED'
             trade['exit_price'] = exit_price
             trade['exit_time'] = datetime.now().isoformat()
             trade['exit_reason'] = reason
             trade['profit_pct'] = profit_pct_display
 
-            # 4. 💰 [المحاسبة] تحديث المحفظة (محفظة واحدة فقط)
             portfolio = await self.r2.get_portfolio_state_async()
             current_capital = float(portfolio.get('current_capital_usd', 100.0))
             
             pnl_usd = current_capital * raw_profit_pct
             new_capital = current_capital + pnl_usd
             
-            # تحديث الإحصائيات التراكمية
             portfolio['current_capital_usd'] = new_capital
             portfolio['total_trades'] = portfolio.get('total_trades', 0) + 1
             
@@ -449,25 +430,21 @@ class TradeManager:
                 portfolio['total_loss_usd'] = portfolio.get('total_loss_usd', 0.0) + abs(pnl_usd)
                 trade['result'] = 'LOSS'
 
-            # تحديث نسبة الفوز
             total_t = portfolio['total_trades']
             if total_t > 0:
                 portfolio['win_rate'] = (portfolio['winning_trades'] / total_t) * 100
             
             trade['pnl_usd'] = pnl_usd 
             
-            # 5. حفظ البيانات في R2
             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 EXECUTED] {symbol} | Reason: {reason} | PnL: {profit_pct_display:.2f}% (${pnl_usd:.2f}) | New Cap: ${new_capital:.2f}")
 
-            # 6. [ 🧠 ] إطلاق المراقب الشبحي إذا كان الخروج بسبب الذكاء الاصطناعي
             if "AI_" in reason:
                 self._launch_post_exit_analysis(symbol, exit_price, trade['exit_time'], current_capital, ai_scores)
 
-            # 7. تنظيف مهام الحارس
             if symbol in self.sentry_tasks:
                 self.sentry_tasks[symbol].cancel()
                 del self.sentry_tasks[symbol]
@@ -478,7 +455,6 @@ class TradeManager:
             if symbol not in self.open_positions:
                  self.open_positions[symbol] = trade 
 
-    # [جديد] دالة للخروج القسري من واجهة المستخدم
     async def force_exit_by_manager(self, symbol, reason):
         print(f"⚠️ [Manager Force Exit] طلب خروج إداري لـ {symbol} بسبب: {reason}")
         current_price = await self.data_manager.get_latest_price_async(symbol)