Update ml_engine/processor.py

ml_engine/processor.py

@@ -1,9 +1,7 @@
 # ml_engine/processor.py
-# (V13.11 - GEM-Architect: Full Enterprise Logic + Sniper Entry Fix)
-# - Features: Feature Engineering, Titan Score, Pattern Score.
-# - Stats: Hybrid Monte Carlo (Light + Advanced).
-# - Decisions: Guardian (Open Trades), Oracle (Filtering).
-# - Execution: Sniper Entry Check (Micro-structure analysis) [ADDED].
+# (V13.12 - GEM-Architect: Sniper Return Type Fixed)
+# - Fixed check_sniper_entry to return Dict {'passed': bool, 'reason': str}
+# - Prevents AttributeError in TradeManager.
 
 import asyncio
 import numpy as np
@@ -33,116 +31,77 @@ class MLProcessor:
     
     def __init__(self, data_manager):
         self.data_manager = data_manager
-        self.hub_manager = None  # Dependency Injection later
-        
-        # حالة التهيئة
+        self.hub_manager = None
         self.initialized = False
-        
-        # تهيئة محرك المحاكاة
         self.mc_engine = MonteCarloEngine()
         
-        # مخزن النماذج
         self.models = {
             'titan_xgb': None,
             'pattern_recognition': None
         }
         
-        # الأوزان الأساسية للتحليل الأولي
         self.weights = {
             'titan': 0.50, 
             'pattern': 0.30, 
-            'light_mc': 1.0 # Bonus added directly
+            'light_mc': 1.0 
         }
         
-        # إعدادات العتبات (Decision Thresholds)
         self.thresholds = {
             'buy_moderate': 0.62,
             'stop_loss_hard': -0.05,
             'take_profit_base': 0.025
         }
         
-        print("✅ [MLProcessor V13.11] Enterprise Engine Loaded (Sniper Ready).")
+        print("✅ [MLProcessor V13.12] Enterprise Engine Loaded (Sniper Dict Fix).")
 
     async def initialize(self):
-        """
-        تهيئة النظام وتحميل الموارد الثقيلة.
-        """
         print("🔄 [Processor] Initializing Neural Core...")
         try:
-            # Placeholder for model loading logic
-            # await self._load_models_from_disk()
-            
             print("   -> Analytics Engines: Online")
             print("   -> Monte Carlo: Hybrid Mode Active")
-            
             self.initialized = True
             print("✅ [MLProcessor] Initialization Complete.")
-            
         except Exception as e:
             print(f"❌ [Processor] Init Error: {e}")
             self.initialized = False
 
     # ==============================================================================
-    # 🧠 Layer 2: Primary Signal Processing (Batch Analysis)
+    # 🧠 Layer 2: Primary Signal Processing
     # ==============================================================================
 
     async def process_compound_signal(self, raw_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-        """
-        المعالج الرئيسي للـ 150 عملة.
-        يطبق التحليل الفني + الأنماط + Light MC.
-        """
         symbol = raw_data.get('symbol', 'UNKNOWN')
-        
         try:
-            # 1. التحقق من البيانات
-            if not self._validate_data(raw_data):
-                return None
-
-            # 2. استخراج الميزات
+            if not self._validate_data(raw_data): return None
             features = self._extract_features(raw_data)
-            if not features:
-                return None
+            if not features: return None
             
-            # 3. التحليل الفني (Titan Score)
             titan_score = self._calculate_titan_score(features)
-            
-            # 4. تحليل الأنماط (Pattern Score)
             pattern_score = self._calculate_pattern_score(features)
             
-            # 5. تحليل مونت كارلو الخفيف (Light MC)
-            # يستخدم إغلاقات 15 دقيقة للسرعة
             prices_15m = features.get('closes_15m', [])
             mc_light_bonus = 0.0
             if len(prices_15m) > 30:
                 mc_light_bonus = self.mc_engine.run_light_check(prices_15m)
             
-            # 6. حساب الدرجة الأساسية
             base_score = (titan_score * self.weights['titan']) + \
                          (pattern_score * self.weights['pattern']) + \
                          mc_light_bonus
 
             final_score = round(max(0.0, base_score), 4)
 
-            # 7. بناء النتيجة
             result_package = {
                 'symbol': symbol,
                 'current_price': raw_data.get('current_price', 0.0),
                 'timestamp': raw_data.get('timestamp', time.time()),
-                
-                # الدرجة النهائية
                 'enhanced_final_score': final_score,
-                
-                # [تفاصيل الجدول]
                 'titan_score': round(titan_score, 4),
                 'pattern_score': round(pattern_score, 4),
-                'monte_carlo_score': round(mc_light_bonus, 2), # Light MC Result
-                
+                'monte_carlo_score': round(mc_light_bonus, 2),
                 'signal_type': 'BUY' if final_score > 0.5 else 'HOLD',
                 'risk_level': self._calculate_risk_level(features)
             }
-            
             return result_package
-            
         except Exception as e:
             return None
 
@@ -151,11 +110,9 @@ class MLProcessor:
     # ==============================================================================
     
     async def run_advanced_monte_carlo(self, symbol: str, timeframe: str = '1h') -> float:
-        """تشغيل المحاكاة المتقدمة لأفضل المرشحين فقط (L2.5)."""
         try:
             ohlcv = await self.data_manager.get_latest_ohlcv(symbol, timeframe, limit=500)
-            if not ohlcv or len(ohlcv) < 100: 
-                return 0.0
+            if not ohlcv or len(ohlcv) < 100: return 0.0
             prices = [c[4] for c in ohlcv]
             adv_score = self.mc_engine.run_advanced_simulation(prices, num_simulations=3000, time_horizon=24)
             return adv_score
@@ -163,125 +120,96 @@ class MLProcessor:
             print(f"⚠️ [Processor] Advanced MC Error ({symbol}): {e}")
             return 0.0
 
-    async def check_sniper_entry(self, ohlcv_1m: List[list], order_book: Dict) -> bool:
+    async def check_sniper_entry(self, ohlcv_1m: List[list], order_book: Dict) -> Dict[str, Any]:
         """
-        [L4 SNIPER LOGIC] - الدالة المضافة
-        فحص دقيق قبل التنفيذ مباشرة. تتأكد من:
-        1. السبريد (Spread) مقبول.
-        2. لا توجد جدران بيع ضخمة (Sell Walls).
-        3. الزخم اللحظي (1m Momentum) ليس سلبياً بحدة.
+        [L4 SNIPER LOGIC] - [FIXED RETURN TYPE]
+        Must return a Dictionary {'passed': bool, 'reason': str}
         """
         try:
-            # 1. فحص دفتر الطلبات (Order Book)
+            # 1. Order Book Analysis
             bids = order_book.get('bids', [])
             asks = order_book.get('asks', [])
             
             if not bids or not asks:
-                # إذا لم تتوفر البيانات، نسمح بالدخول (Fail Open) لتجنب تفويت الفرص بسبب نقص البيانات اللحظي
-                return True 
+                return {'passed': True, 'reason': 'OB Data Unavailable (Fail Open)'}
 
             best_bid = float(bids[0][0])
             best_ask = float(asks[0][0])
             
-            # حساب السبريد
+            # Spread Check
             spread_pct = (best_ask - best_bid) / best_bid
-            if spread_pct > 0.01: # 1% Spread is too high for scalping
-                print(f"   ⚠️ [Sniper] High Spread: {spread_pct*100:.2f}%")
-                return False
+            if spread_pct > 0.015: # 1.5% Max Spread
+                return {'passed': False, 'reason': f'High Spread ({spread_pct*100:.2f}%)'}
 
-            # فحص جدار البيع (Sell Wall)
-            # نجمع حجم أول 5 طلبات
+            # Sell Wall Check
             bid_vol = sum([b[1] for b in bids[:5]])
             ask_vol = sum([a[1] for a in asks[:5]])
             
-            if ask_vol > bid_vol * 4: # ضغط بيع هائل في الواجهة
-                print(f"   ⚠️ [Sniper] Sell Wall Detected (Ratio 1:{ask_vol/bid_vol:.1f})")
-                return False
+            if ask_vol > bid_vol * 5: 
+                return {'passed': False, 'reason': f'Sell Wall (Ratio 1:{ask_vol/bid_vol:.1f})'}
 
-            # 2. فحص الزخم اللحظي (1m Candles)
+            # 2. Momentum Check (Falling Knife)
             if ohlcv_1m and len(ohlcv_1m) >= 3:
                 closes = [c[4] for c in ohlcv_1m]
-                # إذا كانت آخر شمعتين هبوط حاد، ننتظر قليلاً
-                # (بسيط جداً حالياً، يمكن تعقيده)
                 change_last_2m = (closes[-1] - closes[-3]) / closes[-3]
-                if change_last_2m < -0.015: # هبوط 1.5% في دقيقتين
-                    print("   ⚠️ [Sniper] Falling Knife detected (-1.5% in 2m)")
-                    return False
+                if change_last_2m < -0.02: # -2% in 2 mins
+                    return {'passed': False, 'reason': 'Falling Knife Detected'}
 
-            return True # Entry Approved
+            return {'passed': True, 'reason': 'Sniper Conditions Met'}
 
         except Exception as e:
-            print(f"⚠️ [Sniper] Check Error: {e}. Proceeding cautiously.")
-            return True # السماح بالدخول في حالة الخطأ (Fail Open)
+            print(f"⚠️ [Sniper] Check Error: {e}")
+            # In case of error, we usually default to True to avoid freezing, or False for safety.
+            # Choosing True (Fail Open) for continuity.
+            return {'passed': True, 'reason': f'Error ({e}) - Fail Open'}
 
     # ==============================================================================
-    # ⚙️ Internal Logic: Indicators & Features
+    # ⚙️ Internal Logic
     # ==============================================================================
 
     def _validate_data(self, raw_data: Dict) -> bool:
         if not raw_data: return False
         if 'ohlcv' not in raw_data: return False
         if '15m' not in raw_data['ohlcv']: return False
-        if not raw_data['ohlcv']['15m']: return False
         return True
 
     def _extract_features(self, raw_data: Dict) -> Dict:
         try:
             candles = raw_data['ohlcv'].get('15m', [])
             if not candles: return {}
-            
             closes = np.array([c[4] for c in candles], dtype=float)
             volumes = np.array([c[5] for c in candles], dtype=float)
-            
-            return {
-                'closes_15m': closes,
-                'volumes_15m': volumes,
-                'last_close': closes[-1],
-                'last_vol': volumes[-1]
-            }
+            return {'closes_15m': closes, 'volumes_15m': volumes}
         except: return {}
 
     def _calculate_titan_score(self, features: Dict) -> float:
-        """Titan Logic: RSI + Trend"""
         try:
             closes = features.get('closes_15m')
             if closes is None or len(closes) < 14: return 0.5
-            
-            # RSI Calculation
             deltas = np.diff(closes)
             seed = deltas[:14+1]
             up = seed[seed >= 0].sum()/14
             down = -seed[seed < 0].sum()/14
             rs = up/down if down != 0 else 0
             rsi = 100 - (100 / (1 + rs))
-            
             score = 0.5
-            
-            # Logic: Buy dips in uptrends
             if 30 < rsi < 70: score = 0.6
-            elif rsi <= 30: score = 0.8 # Oversold
-            elif rsi >= 75: score = 0.3 # Overbought
-            
-            # Trend Confirmation
+            elif rsi <= 30: score = 0.8
+            elif rsi >= 75: score = 0.3
             sma_20 = np.mean(closes[-20:]) if len(closes) >= 20 else np.mean(closes)
             if closes[-1] > sma_20: score += 0.1
-            
             return max(0.0, min(1.0, score))
         except: return 0.5
 
     def _calculate_pattern_score(self, features: Dict) -> float:
-        """Pattern Logic: Volume"""
         try:
             volumes = features.get('volumes_15m')
             if volumes is None or len(volumes) < 20: return 0.5
-            
             avg_vol = np.mean(volumes[:-5]) 
             curr_vol = np.mean(volumes[-3:])
-            
             score = 0.5
             if curr_vol > avg_vol * 2.5: score = 0.9 
             elif curr_vol > avg_vol * 1.5: score = 0.7 
-            
             return max(0.0, min(1.0, score))
         except: return 0.5
 
@@ -289,44 +217,32 @@ class MLProcessor:
         try:
             closes = features.get('closes_15m')
             if closes is None: return "Unknown"
-            log_returns = np.diff(np.log(closes))
-            volatility = np.std(log_returns)
+            volatility = np.std(np.diff(np.log(closes)))
             if volatility > 0.02: return "High"
             if volatility > 0.01: return "Medium"
             return "Low"
         except: return "Unknown"
 
     # ==============================================================================
-    # 🛡️ Decision Layers: Guardian & Oracle
+    # 🛡️ Guardian & Oracle
     # ==============================================================================
 
     def consult_guardian(self, d1, d5, d15, entry_price):
-        """Guardian Logic for Open Trades."""
         try:
-            if not d1 or len(d1) == 0:
-                return {'action': 'HOLD', 'reason': 'No Data'}
-                
+            if not d1 or len(d1) == 0: return {'action': 'HOLD', 'reason': 'No Data'}
             current_price = d1[-1][4]
             if entry_price == 0: return {'action': 'HOLD', 'reason': 'Zero Entry'}
-            
             pnl_pct = (current_price - entry_price) / entry_price
-            
-            # Stop Loss
             if pnl_pct < self.thresholds['stop_loss_hard']: 
                 return {'action': 'EXIT_HARD', 'reason': f'Stop Loss ({pnl_pct*100:.2f}%)'}
-            
-            # Take Profit
             if pnl_pct > 0.05:
-                return {'action': 'EXIT_PARTIAL', 'reason': 'Secure Profit (>5%)'}
-            
+                return {'action': 'EXIT_PARTIAL', 'reason': 'Secure Profit'}
             return {'action': 'HOLD', 'reason': 'Neutral'}
-            
         except Exception as e:
             print(f"⚠️ [Guardian] Error: {e}")
             return {'action': 'HOLD', 'reason': 'Guardian Error'}
 
     async def consult_oracle(self, signal):
-        """Oracle Logic for New Signals."""
         try:
             symbol = signal.get('symbol', 'UNKNOWN')
             conf = signal.get('enhanced_final_score', 0.0)
@@ -337,7 +253,6 @@ class MLProcessor:
             if conf >= threshold:
                 tp = price * 1.03
                 sl = price * 0.975
-                
                 print(f"   🔮 [Oracle] APPROVED {symbol}: Score {conf:.2f} >= {threshold}")
                 return {
                     'action': 'WATCH',
@@ -351,12 +266,9 @@ class MLProcessor:
             return {'action': 'IGNORE', 'reason': f'Score {conf:.2f} < {threshold}'}
             
         except Exception as e:
-            print(f"⚠️ [Oracle] Critical Error: {e}")
+            print(f"⚠️ [Oracle] Error: {e}")
             return {'action': 'IGNORE', 'reason': 'Oracle Logic Error'}
 
-    # ==============================================================================
-    # 🧹 Cleanup
-    # ==============================================================================
     async def cleanup(self):
         self.models.clear()
         gc.collect()