Update governance_engine.py

governance_engine.py

@@ -1,10 +1,11 @@
 # ============================================================
-# 🏛️ governance_engine.py (V38.1 - GEM-Architect: Full Integrity Fix)
+# 🏛️ governance_engine.py (V39.0 - GEM-Architect: Score-Based Logic)
 # ============================================================
 # Description: 
 #   Evaluates trade quality using 156 INDICATORS.
-#   - Full Logic: Trend, Momentum, Volatility, Volume, Math, Structure.
-#   - Fixed: OrderBook unpacking error (OKX/Binance compatible).
+#   - UPDATE V39.0: REMOVED Strict Domain Veto. 
+#   - Logic: Approval is now purely based on Weighted Score > 50%.
+#   - Safety: OKX/Binance Multi-Exchange Safe (Fixed Unpacking).
 # ============================================================
 
 import numpy as np
@@ -17,7 +18,7 @@ from typing import Dict, Any, List
 
 class GovernanceEngine:
     def __init__(self):
-        # ⚖️ Default Strategic Weights (For Normal/Range Operations)
+        # ⚖️ Default Strategic Weights
         self.DEFAULT_WEIGHTS = {
             "order_book": 0.25,       # 25%
             "market_structure": 0.20, # 20%
@@ -27,7 +28,7 @@ class GovernanceEngine:
             "volatility": 0.05,       # 5%
             "cycle_math": 0.10        # 10%
         }
-        print("🏛️ [Governance Engine V38.1] Context-Aware Protocols Active (Full Integrity).")
+        print("🏛️ [Governance Engine V39.0] Score-Based Approval Protocol Active (No Veto).")
 
     async def evaluate_trade(
         self,
@@ -41,7 +42,7 @@ class GovernanceEngine:
     ) -> Dict[str, Any]:
         """
         Main Execution Entry.
-        Now adapts weights based on 'strategy_type' (SAFE_BOTTOM vs MOMENTUM_LAUNCH).
+        Approval is now purely score-based (>50%).
         """
         try:
             if ta is None:
@@ -63,7 +64,6 @@ class GovernanceEngine:
             if df15 is None:
                 return self._create_rejection("Insufficient Data Length (<60)")
 
-            # optional timeframes (only used when enabled)
             df_map: Dict[str, pd.DataFrame] = {'15m': df15}
             if use_multi_timeframes:
                 for tf in ('1h', '4h', '1d'):
@@ -76,7 +76,7 @@ class GovernanceEngine:
                 print("-" * 80)
 
             # 2) Calculate Domains
-            details_pack = {}  # only filled when include_details=True
+            details_pack = {} 
 
             if not use_multi_timeframes:
                 s_trend = self._calc_trend_domain(df15, verbose, include_details, details_pack)
@@ -86,7 +86,6 @@ class GovernanceEngine:
                 s_cycle = self._calc_cycle_math_domain(df15, verbose, include_details, details_pack)
                 s_struct = self._calc_structure_domain(df15, verbose, include_details, details_pack)
             else:
-                # Weighted by timeframe importance; only timeframes available are used
                 tfw = {'15m': 0.50, '1h': 0.30, '4h': 0.20, '1d': 0.10}
 
                 def _agg(fn, name: str) -> float:
@@ -95,7 +94,7 @@ class GovernanceEngine:
                     per_tf = {}
                     for tf, df_tf in df_map.items():
                         w = tfw.get(tf, 0.1)
-                        s = fn(df_tf, False, include_details, details_pack)  # per-tf verbose off to avoid noise
+                        s = fn(df_tf, False, include_details, details_pack)
                         per_tf[tf] = float(s)
                         acc += w * float(s)
                         total_w += w
@@ -124,56 +123,31 @@ class GovernanceEngine:
             current_weights = self.DEFAULT_WEIGHTS.copy()
             
             if strategy_type == 'SAFE_BOTTOM':
-                # للقاع: نغفر ضعف الترند، ونركز على الرياضيات (الانحراف) والتقلبات والبنية
                 current_weights = {
                     "order_book": 0.20, 
-                    "market_structure": 0.20, # Hammer/Support important
-                    "trend": 0.05,            # Trend is likely negative, ignore it mostly
-                    "momentum": 0.15,         # Divergence matters
+                    "market_structure": 0.20, 
+                    "trend": 0.05,            
+                    "momentum": 0.15,         
                     "volume": 0.10, 
-                    "volatility": 0.15,       # Exhaustion/BB Squeeze
-                    "cycle_math": 0.15        # Mean Reversion / Z-Score
+                    "volatility": 0.15,       
+                    "cycle_math": 0.15        
                 }
             elif strategy_type == 'MOMENTUM_LAUNCH':
-                # للانطلاق: الترند والزخم ودفتر الطلبات هم الملوك
                 current_weights = {
-                    "order_book": 0.25,       # Walls needed to push
+                    "order_book": 0.25,       
                     "market_structure": 0.15, 
-                    "trend": 0.25,            # MUST be uptrending
-                    "momentum": 0.20,         # High RSI is good here
-                    "volume": 0.10,           # Volume backing the move
+                    "trend": 0.25,            
+                    "momentum": 0.20,         
+                    "volume": 0.10,           
                     "volatility": 0.05, 
-                    "cycle_math": 0.00        # Less relevant for breakout
+                    "cycle_math": 0.00        
                 }
 
             # ============================================================
-            # 🛑 1. STRICT CONSENSUS CHECK (Veto Power)
-            # All domains must be non-negative (>= 0).
-            # Exception: For SAFE_BOTTOM, we tolerate negative Trend if other metrics are strong.
+            # 🗑️ DELETED: STRICT CONSENSUS CHECK (Veto Power)
+            # The system now ignores negative individual domains.
+            # It relies solely on the Weighted Score being high enough.
             # ============================================================
-            domain_scores = {
-                "Trend": s_trend,
-                "Momentum": s_mom,
-                "Volatility": s_vol,
-                "Volume": s_volu,
-                "Math": s_cycle,
-                "Structure": s_struct,
-                "OrderBook": s_ob
-            }
-
-            veto_domains = []
-            for name, score in domain_scores.items():
-                if score < 0:
-                    # Special Exemption for Bottom Fishing
-                    if strategy_type == 'SAFE_BOTTOM' and name == 'Trend':
-                        continue 
-                    veto_domains.append(name)
-
-            if veto_domains:
-                reason = f"Vetoed by negative domains: {', '.join(veto_domains)}"
-                if verbose:
-                    print(f"⛔ [Governance VETO] {reason}")
-                return self._create_rejection(reason)
 
             # 3) Weighted Aggregation using DYNAMIC weights
             raw_weighted_score = (
@@ -187,10 +161,11 @@ class GovernanceEngine:
             )
 
             # 4) Final Scoring & Grading
+            # Normalize -1 to 1 range into 0 to 100
             final_score = max(0.0, min(100.0, ((raw_weighted_score + 1) / 2) * 100))
             
             # ============================================================
-            # 🛑 2. SCORE THRESHOLD CHECK (> 50%)
+            # 🛑 SCORE THRESHOLD CHECK (> 50%)
             # ============================================================
             if final_score <= 50.0:
                 if verbose:
@@ -199,6 +174,9 @@ class GovernanceEngine:
 
             grade = self._get_grade(final_score)
 
+            if verbose:
+                print(f"✅ [Governance PASS] Score: {final_score:.2f}% (>50%) | Grade: {grade}")
+
             result = {
                 "governance_score": round(final_score, 2),
                 "grade": grade,
@@ -254,7 +232,6 @@ class GovernanceEngine:
             # 4. Supertrend
             st = ta.supertrend(df['high'], df['low'], c, length=10, multiplier=3)
             if self._valid(st):
-                # Supertrend returns [trend, direction, long, short], usually col 0 is trend line
                 st_line = st.iloc[:, 0] 
                 if c.iloc[-1] > st_line.iloc[-1]: points += 1; details.append("ST:Bull")
                 else: points -= 1
@@ -262,10 +239,8 @@ class GovernanceEngine:
             # 5. Parabolic SAR
             psar = ta.psar(df['high'], df['low'], c)
             if self._valid(psar):
-                # Handle both single series or dataframe return
                 val = psar.iloc[-1]
                 if isinstance(val, pd.Series): val = val.dropna().iloc[0] if not val.dropna().empty else 0
-                
                 if val != 0:
                     if val < c.iloc[-1]: points += 1; details.append("PSAR:Bull")
                     else: points -= 1
@@ -283,7 +258,6 @@ class GovernanceEngine:
 
             # 7. Ichimoku
             ichi = ta.ichimoku(df['high'], df['low'], c)
-            # Ichimoku returns a tuple of (DataFrame, DataFrame)
             if ichi is not None and isinstance(ichi, tuple) and self._valid(ichi[0]):
                 span_a = ichi[0][ichi[0].columns[0]].iloc[-1]
                 span_b = ichi[0][ichi[0].columns[1]].iloc[-1]
@@ -449,7 +423,7 @@ class GovernanceEngine:
             if self._valid(uo) and uo.iloc[-1] > 50: 
                 points += 0.5; details.append("UO:>50")
 
-            # 16. KDJ (kdj returns df)
+            # 16. KDJ
             kdj = ta.kdj(df['high'], df['low'], c)
             if self._valid(kdj) and kdj[kdj.columns[0]].iloc[-1] > kdj[kdj.columns[1]].iloc[-1]: 
                 points += 0.5; details.append("KDJ:Bull")
@@ -491,29 +465,21 @@ class GovernanceEngine:
         points = 0.0
         details = []
         try:
-            # 1. Bollinger Bands (Bandwidth + %B)
+            # 1. Bollinger Bands
             bb = ta.bbands(df['close'], length=20)
             if self._valid(bb):
-                # pandas_ta names usually: BBL_, BBM_, BBU_, BBB_ (bandwidth), BBP_ (%B)
                 bw_col = self._find_col(bb, ["bbb_", "bandwidth", "bbw"])
                 pb_col = self._find_col(bb, ["bbp_", "%b", "percentb", "pb"])
                 width = self._safe_last(bb, col=bw_col) if bw_col else np.nan
                 pct_b = self._safe_last(bb, col=pb_col) if pb_col else np.nan
 
-                # Bandwidth: smaller -> squeeze, larger -> expansion
-                # Typical BBB values ~ 0.02 - 0.25 in many markets (depends on volatility)
                 if np.isfinite(width):
-                    if width < 0.05:
-                        points -= 1; details.append("BBW:Squeeze")
-                    elif width > 0.18:
-                        points += 1; details.append("BBW:Expand")
+                    if width < 0.05: points -= 1; details.append("BBW:Squeeze")
+                    elif width > 0.18: points += 1; details.append("BBW:Expand")
 
-                # %B: location within bands (0..1 typically)
                 if np.isfinite(pct_b):
-                    if pct_b > 0.90:
-                        points += 0.5; details.append("BB%B:High")
-                    elif pct_b < 0.10:
-                        points -= 0.5; details.append("BB%B:Low")
+                    if pct_b > 0.90: points += 0.5; details.append("BB%B:High")
+                    elif pct_b < 0.10: points -= 0.5; details.append("BB%B:Low")
 
             # 3. ATR
             atr = ta.atr(df['high'], df['low'], df['close'], length=14)
@@ -566,7 +532,7 @@ class GovernanceEngine:
                 vr = atr.iloc[-1] / atr.iloc[-20]
                 if vr > 1.2: points += 1; details.append("VolRatio:High")
 
-            # 12. RVI (Proxy)
+            # 12. RVI
             if self._valid(c_vol):
                 std_rsi = ta.rsi(c_vol, length=14)
                 if self._valid(std_rsi) and std_rsi.iloc[-1] > 50: points += 0.5
@@ -857,7 +823,7 @@ class GovernanceEngine:
         return norm_score
 
     # ==============================================================================
-    # 📖 DOMAIN 7: ORDER BOOK (FIXED & SAFE)
+    # 📖 DOMAIN 7: ORDER BOOK (Safe Unpacking)
     # ==============================================================================
     def _calc_orderbook_domain(self, ob: Dict[str, Any], verbose: bool, include_details: bool = False, details_pack: Any = None) -> float:
         points = 0.0
@@ -865,13 +831,12 @@ class GovernanceEngine:
         if not ob or 'bids' not in ob or 'asks' not in ob: return 0.0
         
         try:
-            # ✅ Safe Numpy Conversion (Fixes OKX Unpacking)
+            # ✅ Safe Numpy Conversion
             bids = np.array(ob['bids'], dtype=float)
             asks = np.array(ob['asks'], dtype=float)
             
             if len(bids) < 20 or len(asks) < 20: return 0.0
 
-            # Safe Slicing (Ignores extra columns if present)
             bid_vol = np.sum(bids[:20, 1])
             ask_vol = np.sum(asks[:20, 1])
             imbal = (bid_vol - ask_vol) / (bid_vol + ask_vol)
@@ -887,12 +852,11 @@ class GovernanceEngine:
 
             if bid_vol > ask_vol * 1.5: points += 2; details.append("Depth:Bull")
             
-            # Slippage / depth-to-move
             mid = (asks[0, 0] + bids[0, 0]) / 2.0
-            target_p = mid * 1.005  # ~0.5% up move
+            target_p = mid * 1.005  
             vol_needed = 0.0
             
-            # ✅ Safe Iteration (Fixes Unpacking Error)
+            # ✅ Safe Loop Fix
             for row in asks:
                 p = row[0]
                 s = row[1]
@@ -931,109 +895,49 @@ class GovernanceEngine:
     # 🔧 Utilities
     # ==============================================================================
     def _valid(self, item, col: Any = None) -> bool:
-        """Return True if item has a finite last value (Series) or at least one finite last-row value (DataFrame).
-        If col is provided and item is a DataFrame, checks that column's last value.
-        """
-        if item is None:
-            return False
-
-        # pandas_ta sometimes returns tuples (e.g., ichimoku)
-        if isinstance(item, tuple):
-            # consider valid if any element is valid
-            return any(self._valid(x, col=col) for x in item)
-
+        if item is None: return False
+        if isinstance(item, tuple): return any(self._valid(x, col=col) for x in item)
         try:
-            if isinstance(item, pd.Series):
-                if item.empty:
-                    return False
-                v = item.iloc[-1]
-                return pd.notna(v) and np.isfinite(v)
-
+            if isinstance(item, pd.Series): return pd.notna(item.iloc[-1]) and np.isfinite(item.iloc[-1])
             if isinstance(item, pd.DataFrame):
-                if item.empty:
-                    return False
-                if col is not None:
-                    c = self._find_col(item, [col]) or (col if col in item.columns else None)
-                    if c is None:
-                        return False
-                    v = item[c].iloc[-1]
-                    return pd.notna(v) and np.isfinite(v)
-                # any finite in last row
-                last = item.iloc[-1]
-                if isinstance(last, pd.Series):
-                    vals = last.values.astype(float, copy=False)
-                    return np.isfinite(vals).any()
-                return False
-
-            # scalars
-            if isinstance(item, (int, float, np.number)):
-                return np.isfinite(item)
+                if col: return self._valid(item[col]) if col in item.columns else False
+                return True
+            if isinstance(item, (int, float)): return np.isfinite(item)
             return True
+        except: return False
 
-        except Exception:
-            return False
-
-    def _find_col(self, df: pd.DataFrame, contains_any: List[str]) -> Any:
-        """Find first column whose name contains any of the provided substrings (case-insensitive)."""
-        if df is None or getattr(df, "empty", True):
-            return None
-        cols = list(df.columns)
-        lowered = [str(c).lower() for c in cols]
-        needles = [s.lower() for s in contains_any]
-        for n in needles:
-            for c, lc in zip(cols, lowered):
-                if n in lc:
-                    return c
+    def _find_col(self, df, contains_any):
+        if df is None: return None
+        for c in df.columns:
+            for n in contains_any:
+                if n.lower() in str(c).lower(): return c
         return None
 
-    def _safe_last(self, item, default=np.nan, col: Any = None) -> float:
-        """Safely get last finite value from Series/DataFrame (optionally from matched column)."""
-        if not self._valid(item, col=col):
-            return float(default)
+    def _safe_last(self, item, default=np.nan, col=None):
+        if not self._valid(item, col=col): return float(default)
         try:
-            if isinstance(item, pd.Series):
-                return float(item.iloc[-1])
+            if isinstance(item, pd.Series): return float(item.iloc[-1])
             if isinstance(item, pd.DataFrame):
-                if col is None:
-                    # pick first finite value in last row
-                    last = item.iloc[-1]
-                    for v in last.values:
-                        if pd.notna(v) and np.isfinite(v):
-                            return float(v)
-                    return float(default)
-                c = self._find_col(item, [col]) or (col if col in item.columns else None)
-                if c is None:
-                    return float(default)
-                return float(item[c].iloc[-1])
-            if isinstance(item, (int, float, np.number)):
-                return float(item)
-            return float(default)
-        except Exception:
-            return float(default)
-
-    def _normalize(self, value: float, max_possible: float) -> float:
+                c = self._find_col(item, [col]) if col else item.columns[0]
+                return float(item[c].iloc[-1]) if c else float(default)
+            return float(item)
+        except: return float(default)
+
+    def _normalize(self, value, max_possible):
         if max_possible == 0: return 0.0
         return max(-1.0, min(1.0, value / max_possible))
 
-    def _prepare_dataframe(self, ohlcv: List) -> pd.DataFrame:
+    def _prepare_dataframe(self, ohlcv):
         df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
         df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
         df.set_index('timestamp', inplace=True)
-        cols = ['open', 'high', 'low', 'close', 'volume']
-        df[cols] = df[cols].astype(float)
         return df
 
-    def _get_grade(self, score: float) -> str:
+    def _get_grade(self, score):
         if score >= 85: return "ULTRA"
         if score >= 70: return "STRONG"
         if score > 50: return "NORMAL"
         return "REJECT"
 
-    def _create_rejection(self, reason: str):
-        return {
-            "governance_score": 0.0,
-            "grade": "REJECT",
-            "status": "REJECTED",
-            "reason": reason,
-            "components": {}
-        }
+    def _create_rejection(self, reason):
+        return {"governance_score": 0.0, "status": "REJECTED", "reason": reason, "components": {}}