Update ml_engine/processor.py

ml_engine/processor.py

@@ -1,7 +1,7 @@
 # ml_engine/processor.py
-# (V13.12 - GEM-Architect: Sniper Return Type Fixed)
-# - Fixed check_sniper_entry to return Dict {'passed': bool, 'reason': str}
-# - Prevents AttributeError in TradeManager.
+# (V13.13 - GEM-Architect: Sniper Signal Key Fix)
+# - Added 'signal' key to check_sniper_entry return dict.
+# - Fixes KeyError in TradeManager.
 
 import asyncio
 import numpy as np
@@ -52,7 +52,7 @@ class MLProcessor:
             'take_profit_base': 0.025
         }
         
-        print("✅ [MLProcessor V13.12] Enterprise Engine Loaded (Sniper Dict Fix).")
+        print("✅ [MLProcessor V13.13] Enterprise Engine Loaded (Sniper Signal Fix).")
 
     async def initialize(self):
         print("🔄 [Processor] Initializing Neural Core...")
@@ -122,8 +122,7 @@ class MLProcessor:
 
     async def check_sniper_entry(self, ohlcv_1m: List[list], order_book: Dict) -> Dict[str, Any]:
         """
-        [L4 SNIPER LOGIC] - [FIXED RETURN TYPE]
-        Must return a Dictionary {'passed': bool, 'reason': str}
+        [L4 SNIPER LOGIC] - [FIXED] Returns 'signal' key.
         """
         try:
             # 1. Order Book Analysis
@@ -131,37 +130,61 @@ class MLProcessor:
             asks = order_book.get('asks', [])
             
             if not bids or not asks:
-                return {'passed': True, 'reason': 'OB Data Unavailable (Fail Open)'}
+                # Fail Open if data missing to avoid blocking
+                return {
+                    'passed': True, 
+                    'signal': 'BUY', 
+                    '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.015: # 1.5% Max Spread
-                return {'passed': False, 'reason': f'High Spread ({spread_pct*100:.2f}%)'}
+            if spread_pct > 0.015: 
+                return {
+                    'passed': False, 
+                    'signal': 'HOLD', 
+                    'reason': f'High Spread ({spread_pct*100:.2f}%)'
+                }
 
             # 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 * 5: 
-                return {'passed': False, 'reason': f'Sell Wall (Ratio 1:{ask_vol/bid_vol:.1f})'}
+                return {
+                    'passed': False, 
+                    'signal': 'HOLD', 
+                    'reason': f'Sell Wall (Ratio 1:{ask_vol/bid_vol:.1f})'
+                }
 
             # 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.02: # -2% in 2 mins
-                    return {'passed': False, 'reason': 'Falling Knife Detected'}
+                if change_last_2m < -0.02:
+                    return {
+                        'passed': False, 
+                        'signal': 'HOLD', 
+                        'reason': 'Falling Knife Detected'
+                    }
 
-            return {'passed': True, 'reason': 'Sniper Conditions Met'}
+            return {
+                'passed': True, 
+                'signal': 'BUY', 
+                'reason': 'Sniper Conditions Met'
+            }
 
         except Exception as e:
             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'}
+            # Default to BUY on error (Fail Open) to ensure execution continuity
+            return {
+                'passed': True, 
+                'signal': 'BUY', 
+                'reason': f'Error ({e}) - Fail Open'
+            }
 
     # ==============================================================================
     # ⚙️ Internal Logic
@@ -217,14 +240,15 @@ class MLProcessor:
         try:
             closes = features.get('closes_15m')
             if closes is None: return "Unknown"
-            volatility = np.std(np.diff(np.log(closes)))
+            log_returns = np.diff(np.log(closes))
+            volatility = np.std(log_returns)
             if volatility > 0.02: return "High"
             if volatility > 0.01: return "Medium"
             return "Low"
         except: return "Unknown"
 
     # ==============================================================================
-    # 🛡️ Guardian & Oracle
+    # 🛡️ Decision Layers
     # ==============================================================================
 
     def consult_guardian(self, d1, d5, d15, entry_price):
@@ -247,7 +271,6 @@ class MLProcessor:
             symbol = signal.get('symbol', 'UNKNOWN')
             conf = signal.get('enhanced_final_score', 0.0)
             price = signal.get('current_price', 0)
-            
             threshold = self.thresholds['buy_moderate']
             
             if conf >= threshold:
@@ -261,12 +284,10 @@ class MLProcessor:
                     'sl_price': sl,
                     'reason': f'Approved (Score {conf:.2f})'
                 }
-            
             print(f"   🔮 [Oracle] REJECTED {symbol}: Score {conf:.2f} < {threshold}")
             return {'action': 'IGNORE', 'reason': f'Score {conf:.2f} < {threshold}'}
-            
         except Exception as e:
-            print(f"⚠️ [Oracle] Error: {e}")
+            print(f"⚠️ [Oracle] Critical Error: {e}")
             return {'action': 'IGNORE', 'reason': 'Oracle Logic Error'}
 
     async def cleanup(self):