Update trade_manager.py

trade_manager.py

@@ -1,116 +1,345 @@
-# trade_manager.py (V12.3 - Hybrid Executor with Correct Naming)
+# trade_manager.py (V13.1 - Tactical Sniper with Full Reporting)
 
 import asyncio
 import time
 import json
-from datetime import datetime
-from typing import Dict, List, Deque
+import traceback
+from datetime import datetime, timezone
+from typing import Dict, List, Deque, Optional
 from collections import deque
 import numpy as np
 import ccxt.async_support as ccxtasync
 
+# استيراد التبعيات الضرورية للتحليل اللحظي
+try:
+    from ml_engine.titan_engine import TitanEngine
+    from ml_engine.patterns import ChartPatternAnalyzer
+except ImportError:
+    TitanEngine = None
+    ChartPatternAnalyzer = None
+    print("⚠️ [TradeManager] Warning: ML engines not found. Sniper mode will be limited.")
+
 class TacticalData:
+    """حاوية بيانات تكتيكية سريعة للمراقبة اللحظية"""
     def __init__(self, symbol):
         self.symbol = symbol
         self.order_book = None
-        self.trades = deque(maxlen=1000)
-        self.ohlcv = {tf: deque(maxlen=500) for tf in ['5m', '15m', '1h', '4h', '1d']}
+        self.trades = deque(maxlen=1000) # آخر 1000 صفقة لتتبع الزخم
+        # نحتاج فريم 5 دقائق بشكل أساسي للزناد، و 1 ساعة للسياق
+        self.ohlcv = {tf: deque(maxlen=300) for tf in ['5m', '1h']}
         self.last_update = time.time()
 
     def update_ohlcv(self, tf, candles):
         if not candles: return
-        current = self.ohlcv[tf]
-        last_ts = current[-1][0] if len(current) > 0 else 0
-        new_candles = [c for c in candles if c[0] > last_ts]
-        current.extend(new_candles)
+        current = self.ohlcv.get(tf)
+        if current is None: return
+        
+        # دمج الشموع الجديدة بكفاءة
+        if len(current) == 0:
+            current.extend(candles)
+        else:
+            last_ts = current[-1][0]
+            new_candles = [c for c in candles if c[0] > last_ts]
+            current.extend(new_candles)
+            # تحديث الشمعة الأخيرة إذا كانت لا تزال مفتوحة
+            if candles[-1][0] == last_ts:
+                 current[-1] = candles[-1]
 
-    def get_full_packet(self):
-        if len(self.ohlcv['5m']) < 200 or len(self.ohlcv['1h']) < 200:
-            return None
-        return {tf: list(data) for tf, data in self.ohlcv.items()}
+    def is_ready_for_analysis(self):
+        # نحتاج على الأقل 100 شمعة 5 دقائق لتحليل فني معقول
+        return len(self.ohlcv['5m']) >= 100
 
 class TradeManager:
     def __init__(self, r2_service, data_manager, titan_engine=None, processor=None):
         self.r2 = r2_service
         self.dm = data_manager
-        self.titan = titan_engine
-        self.processor = processor # (اختياري للاستخدام المستقبلي للهجين الكامل في الحارس)
+        # استخدام محركات خاصة للحارس لضمان عدم تضارب الذاكرة مع المستكشف
+        self.titan = TitanEngine() if TitanEngine else None
+        self.pattern_analyzer = ChartPatternAnalyzer() if ChartPatternAnalyzer else None
         
         self.is_running = False
-        self.watchlist = {}
+        self.watchlist = {} # العملات قيد المراقبة للدخول
+        self.open_positions = {} # العملات التي تم الدخول فيها
         self.tasks = {}
         self.data_cache = {}
         self.lock = asyncio.Lock()
         self.exchange = None
         
-        # استيراد العتبة بالاسم الهجين الجديد
-        self.ENTRY_THRESH = self.dm.HYBRID_ENTRY_THRESHOLD if self.dm else 0.90
-        print(f"⚔️ [TradeManager] Hybrid Executor Ready. Entry Threshold: {self.ENTRY_THRESH}")
+        # إعدادات القناص
+        self.SNIPER_ENTRY_THRESHOLD = 0.75 # عتبة دخول لحظية مرتفعة
+        self.MOMENTUM_CONFIRMATION = True # تطلب تأكيد الزخم من دفتر الطلبات
+        
+        print(f"⚔️ [Sniper] Tactical Trade Manager Initialized. Entry Threshold: {self.SNIPER_ENTRY_THRESHOLD}")
 
     async def initialize_sentry_exchanges(self):
-        self.exchange = ccxtasync.kucoin({'enableRateLimit': True, 'timeout': 20000})
-        await self.exchange.load_markets()
+        """تهيئة اتصال المنصة الخاص بالحارس"""
+        try:
+            if not self.exchange:
+                self.exchange = ccxtasync.kucoin({
+                    'enableRateLimit': True, 
+                    'timeout': 15000, # تايم آوت أقصر للاستجابة السريعة
+                    'options': {'defaultType': 'spot'}
+                })
+                await self.exchange.load_markets()
+            
+            # تهيئة المحركات اللحظية
+            if self.titan and not self.titan.initialized: await self.titan.initialize()
+            if self.pattern_analyzer and not self.pattern_analyzer.initialized: await self.pattern_analyzer.initialize()
+            
+        except Exception as e:
+            print(f"❌ [Sniper Init Error] {e}")
 
     async def start_sentry_loops(self):
+        """بدء حلقة المراقبة الرئيسية"""
         self.is_running = True
+        print("🔭 [Sniper] Sentry loops started.")
         while self.is_running:
-            await asyncio.sleep(5)
-            async with self.lock:
-                targets = list(self.watchlist.keys())
-            for sym in targets:
-                if sym not in self.tasks:
-                    print(f"🛡️ [Sentry] Starting monitor for {sym}")
-                    self.data_cache[sym] = TacticalData(sym)
-                    self.tasks[sym] = asyncio.create_task(self._monitor_symbol(sym))
+            try:
+                # 1. إدارة قائمة المراقبة (للدخول)
+                async with self.lock:
+                    watch_targets = list(self.watchlist.keys())
+                
+                for sym in watch_targets:
+                    if sym not in self.tasks:
+                        print(f"🎯 [Sniper] Locking on target: {sym}")
+                        self.data_cache[sym] = TacticalData(sym)
+                        self.tasks[sym] = asyncio.create_task(self._monitor_for_entry(sym))
+
+                # 2. إدارة الصفقات المفتوحة (للخروج)
+                # (سيتم إضافتها لاحقاً: self._monitor_open_positions())
+                
+                await asyncio.sleep(5) # دورة تفقد رئيسية سريعة
+            except Exception as e:
+                print(f"⚠️ [Sentry Loop Error] {e}")
+                await asyncio.sleep(5)
 
     async def stop_sentry_loops(self):
         self.is_running = False
         for t in self.tasks.values(): t.cancel()
         if self.exchange: await self.exchange.close()
+        print("🛡️ [Sniper] Sentry stood down.")
 
     async def update_sentry_watchlist(self, candidates):
+        """تحديث قائمة الأهداف من المستكشف"""
         async with self.lock:
-            self.watchlist = {c['symbol']: c for c in candidates}
-        print(f"📋 [Sentry] Watchlist updated: {len(candidates)} targets.")
+            # إضافة أهداف جديدة فقط
+            for cand in candidates:
+                sym = cand['symbol']
+                if sym not in self.watchlist and sym not in self.open_positions:
+                    self.watchlist[sym] = cand
+                    print(f"📋 [Sniper] New target acquired: {sym}")
 
-    async def _monitor_symbol(self, symbol):
+    # ==================================================================
+    # 🎯 منطق القناص (Entry Logic)
+    # ==================================================================
+    async def _monitor_for_entry(self, symbol):
+        """مراقبة لحظية مكثفة لهدف محدد بغرض الدخول"""
+        print(f"👁️ [Sniper] Monitoring {symbol} for tactical entry...")
+        consecutive_signals = 0
+        
         while self.is_running and symbol in self.watchlist:
             try:
-                tfs = ['5m', '15m', '1h', '4h', '1d']
-                tasks = [self.exchange.fetch_ohlcv(symbol, tf, limit=100) for tf in tfs]
-                tasks.append(self.exchange.fetch_order_book(symbol, limit=20))
+                # 1. تحديث البيانات التكتيكية (5m + 1h + OrderBook)
+                tfs = ['5m', '1h']
+                tasks = [self.exchange.fetch_ohlcv(symbol, tf, limit=150) for tf in tfs]
+                tasks.append(self.exchange.fetch_order_book(symbol, limit=50))
                 results = await asyncio.gather(*tasks, return_exceptions=True)
                 
                 data = self.data_cache[symbol]
-                for i, tf in enumerate(tfs):
-                    if isinstance(results[i], list):
-                        data.update_ohlcv(tf, results[i])
-                if not isinstance(results[-1], Exception):
+                valid_update = True
+                for i, res in enumerate(results[:-1]):
+                    if isinstance(res, list):
+                        data.update_ohlcv(tfs[i], res)
+                    else:
+                        valid_update = False
+                
+                if isinstance(results[-1], dict):
                     data.order_book = results[-1]
 
-                # حالياً الحارس يستخدم Titan فقط للسرعة في المراقبة اللحظية
-                # (يمكن ترقيته لاستخدام الهجين الكامل processor.process... لاحقاً إذا لزم الأمر)
-                packet = data.get_full_packet()
-                if packet and self.titan:
-                    prediction = self.titan.predict(packet)
-                    score = prediction.get('score', 0.0)
+                if not valid_update or not data.is_ready_for_analysis():
+                    await asyncio.sleep(10) # انتظار تجميع البيانات
+                    continue
+
+                # 2. التحليل اللحظي الجديد (Fresh Analysis)
+                # أ. تحليل Titan اللحظي (5m)
+                titan_score = 0.0
+                if self.titan:
+                    # تجهيز البيانات لـ Titan (يحتاج قاموس بجميع الفريمات المتاحة)
+                    titan_packet = {tf: list(data.ohlcv[tf]) for tf in tfs}
+                    titan_res = await asyncio.to_thread(self.titan.predict, titan_packet)
+                    titan_score = titan_res.get('score', 0.0)
+
+                # ب. تحليل الأنماط اللحظي (5m)
+                pattern_score = 0.0
+                bullish_pattern = False
+                if self.pattern_analyzer:
+                    # تحليل آخر 100 شمعة 5 دقائق فقط
+                    candles_5m = list(data.ohlcv['5m'])[-100:]
+                    pat_res = await self.pattern_analyzer.detect_chart_patterns({'5m': candles_5m})
+                    pattern_score = pat_res.get('pattern_confidence', 0.0)
+                    if pat_res.get('pattern_detected') and 'BULLISH' in pat_res['pattern_detected'].upper():
+                        bullish_pattern = True
+
+                # ج. تحليل زخم دفتر الطلبات (Order Book Imbalance)
+                ob_imbalance = self._calculate_ob_imbalance(data.order_book)
+                momentum_confirmed = ob_imbalance > 0.15 # طلبات الشراء أكثر بـ 15%
+
+                # 3. قرار الزناد (The Trigger)
+                # الشروط: Titan قوي جدًا OR (Titan جيد AND نمط إيجابي AND زخم دفتر طلبات)
+                sniper_fired = False
+                trigger_reason = ""
+                
+                if titan_score >= self.SNIPER_ENTRY_THRESHOLD:
+                     sniper_fired = True
+                     trigger_reason = f"Titan Surge ({titan_score:.2f})"
+                elif titan_score >= 0.65 and bullish_pattern and momentum_confirmed:
+                     sniper_fired = True
+                     trigger_reason = f"Tactical Combo (Titan:{titan_score:.2f} + Pattern + OB:{ob_imbalance:.2f})"
+
+                if sniper_fired:
+                    consecutive_signals += 1
+                    print(f"🔥 [Sniper] {symbol} Signal detected! ({consecutive_signals}/2) - {trigger_reason}")
                     
-                    if score >= self.ENTRY_THRESH:
-                        print(f"🚀 [EXECUTOR] Hybrid Signal Re-confirmed by Titan! {symbol} Score: {score:.4f}")
-                        await self._execute_entry(symbol, score)
-                        async with self.lock: self.watchlist.pop(symbol, None)
-                        break
+                    # نطلب تأكيد إشارتين متتاليتين لتقليل الإشارات الكاذبة
+                    if consecutive_signals >= 2:
+                        await self._execute_buy(symbol, trigger_reason, titan_score)
+                        break # الخروج من حلقة المراقبة بعد الشراء
+                else:
+                    consecutive_signals = max(0, consecutive_signals - 1) # تبريد العداد
 
-                await asyncio.sleep(60)
+                await asyncio.sleep(30) # مراقبة كل 30 ثانية (سريع)
+                
+            except asyncio.CancelledError:
+                break
             except Exception as e:
                 print(f"⚠️ [Monitor Error] {symbol}: {e}")
+                await asyncio.sleep(60) # تهدئة عند الخطأ
+
+    def _calculate_ob_imbalance(self, ob):
+        """حساب عدم توازن دفتر الطلبات (ميل نحو الشراء أو البيع)"""
+        if not ob or 'bids' not in ob or 'asks' not in ob: return 0.0
+        # حساب حجم أفضل 10 طلبات وعروض
+        bids_vol = sum(b[1] for b in ob['bids'][:10])
+        asks_vol = sum(a[1] for a in ob['asks'][:10])
+        if (bids_vol + asks_vol) == 0: return 0.0
+        return (bids_vol - asks_vol) / (bids_vol + asks_vol)
+
+    # ==================================================================
+    # 🚀 التنفيذ وإدارة الصفقات (Execution & Mgmt)
+    # ==================================================================
+    async def _execute_buy(self, symbol, reason, score):
+        """تنفيذ الشراء الافتراضي وتسجيل الصفقة"""
+        try:
+            # 1. جلب السعر الحالي للتنفيذ
+            ticker = await self.exchange.fetch_ticker(symbol)
+            entry_price = ticker['last']
+            
+            # 2. حساب حجم الصفقة (إدارة مخاطر بسيطة: 10% من رأس المال الوهمي)
+            portfolio = await self.r2.get_portfolio_state_async()
+            capital = portfolio.get('current_capital_usd', 1000.0)
+            trade_amount_usd = capital * 0.10
+            quantity = trade_amount_usd / entry_price
+
+            # 3. إنشاء سجل الصفقة
+            trade = {
+                "symbol": symbol,
+                "status": "OPEN",
+                "entry_price": entry_price,
+                "quantity": quantity,
+                "invested_usd": trade_amount_usd,
+                "entry_time": datetime.now(timezone.utc).isoformat(),
+                "entry_reason": reason,
+                "entry_score": score,
+                # أهداف أولية (يمكن للحارس تعديلها لاحقاً)
+                "tp_price": entry_price * 1.025, # هدف 2.5%
+                "sl_price": entry_price * 0.98,  # وقف 2%
+                "highest_price": entry_price     # لتتبع الوقف المتحرك
+            }
+
+            # 4. نقل من قائمة المراقبة إلى الصفقات المفتوحة
+            async with self.lock:
+                if symbol in self.watchlist:
+                    del self.watchlist[symbol]
+                self.open_positions[symbol] = trade
+                
+            # 5. حفظ في R2 (اختياري: يمكن حفظ الصفقات المفتوحة أيضاً)
+            # await self.r2.save_open_trades_async(list(self.open_positions.values()))
+            
+            print(f"🚀 [EXECUTED] BUY {symbol} @ {entry_price} | Reason: {reason}")
+            
+            # بدء مراقبة هذه الصفقة المفتوحة فوراً
+            asyncio.create_task(self._monitor_open_position(symbol))
+
+        except Exception as e:
+            print(f"❌ [Execution Failed] {symbol}: {e}")
+
+    async def _monitor_open_position(self, symbol):
+        """حارس الأرباح: مراقبة صفقة مفتوحة حتى الإغلاق"""
+        print(f"🛡️ [Guardian] Protecting position: {symbol}")
+        while self.is_running and symbol in self.open_positions:
+            try:
+                trade = self.open_positions[symbol]
+                ticker = await self.exchange.fetch_ticker(symbol)
+                current_price = ticker['last']
+                
+                # تحديث أعلى سعر وصل له لتفعيل الوقف المتحرك
+                if current_price > trade['highest_price']:
+                    trade['highest_price'] = current_price
+                    # تفعيل وقف متحرك إذا تجاوز الربح 1%
+                    if current_price >= trade['entry_price'] * 1.01:
+                         new_sl = current_price * 0.995 # حجز 0.5% تحت أعلى قمة
+                         if new_sl > trade['sl_price']:
+                             trade['sl_price'] = new_sl
+                             print(f"🛡️ [Guardian] {symbol} Trailing SL moved to {new_sl:.4f}")
+
+                # التحقق من شروط الخروج
+                close_reason = None
+                if current_price >= trade['tp_price']:
+                    close_reason = "TAKE_PROFIT"
+                elif current_price <= trade['sl_price']:
+                    close_reason = "STOP_LOSS"
+
+                if close_reason:
+                    await self._execute_sell(symbol, current_price, close_reason)
+                    break
+
+                await asyncio.sleep(5) # مراقبة لصيقة جداً للصفقات المفتوحة
+
+            except Exception as e:
+                print(f"⚠️ [Guardian Error] {symbol}: {e}")
                 await asyncio.sleep(10)
 
-    async def _execute_entry(self, symbol, score):
-        price = (await self.exchange.fetch_ticker(symbol))['last']
-        trade = {
-            "symbol": symbol, "entry_price": price, "score": score,
-            "timestamp": datetime.now().isoformat(), "status": "OPEN",
-            "tp": price * 1.015, "sl": price * 0.9925
-        }
-        print(f"✅ [TRADE OPENED] {json.dumps(trade, indent=2)}")
+    async def _execute_sell(self, symbol, exit_price, reason):
+        """تنفيذ البيع وتسجيل التقارير النهائية"""
+        async with self.lock:
+            trade = self.open_positions.pop(symbol, None)
+            
+        if trade:
+            # 1. حساب النتائج
+            gross_pnl = (exit_price - trade['entry_price']) * trade['quantity']
+            # خصم رسوم وهمية (0.1% دخول + 0.1% خروج)
+            fees = (trade['invested_usd'] + (exit_price * trade['quantity'])) * 0.001
+            net_pnl = gross_pnl - fees
+            pnl_percent = (net_pnl / trade['invested_usd']) * 100
+
+            # 2. تحديث بيانات الصفقة
+            trade.update({
+                "status": "CLOSED",
+                "exit_price": exit_price,
+                "exit_time": datetime.now(timezone.utc).isoformat(),
+                "exit_reason": reason,
+                "pnl_usd": net_pnl,
+                "pnl_percent": pnl_percent,
+                "fees_paid": fees
+            })
+
+            print(f"💰 [CLOSED] {symbol} ({reason}) | PnL: ${net_pnl:.2f} ({pnl_percent:.2f}%)")
+
+            # 3. حفظ التقارير عبر R2 (النظام الجديد)
+            # أ. حفظ الصفقة المغلقة وتحديث ملخص التداول
+            await self.r2.save_closed_trade_async(trade)
+            # ب. تحديث رصيد المحفظة
+            await self.r2.update_portfolio_balance_async(net_pnl)
+
+        if symbol in self.tasks:
+            del self.tasks[symbol]