Update smart_portfolio.py

smart_portfolio.py

@@ -1,10 +1,5 @@
 # ==============================================================================
-# 💼 smart_portfolio.py (V36.0 - GEM-Architect: Regime-Aligned Risk)
-# ==============================================================================
-# التحديثات:
-# 1. إلغاء تحديد الاتجاه المستقل. الاعتماد الكلي على SystemLimits.CURRENT_REGIME.
-# 2. إدارة الخانات الديناميكية (Dynamic Slots) بناءً على حالة السوق.
-# 3. تعديل مضاعفات المخاطرة (Risk Multipliers) لتتوافق مع الـ DNA الحالي.
+# 💼 smart_portfolio.py (V37.0 - GEM-Architect: Grade-Based Sizing)
 # ==============================================================================
 
 import asyncio
@@ -33,17 +28,8 @@ class SmartPortfolio:
         self.MIN_CAPITAL_FOR_SPLIT = 20.0
         self.DAILY_LOSS_LIMIT_PCT = 0.20
         
-        # 📊 أوزان الثقة المركبة
-        self.WEIGHTS = {
-            "L2_TECHNICAL": 0.25, 
-            "L3_ORACLE": 0.35,     
-            "L4_SNIPER": 0.20,     
-            "CONTEXT": 0.10,       
-            "MARKET_MOOD": 0.10    
-        }
-        
-        # حالة السوق (تقرأ الآن من SystemLimits)
-        self.market_trend = "NEUTRAL" # للعرض فقط
+        # حالة السوق
+        self.market_trend = "NEUTRAL"
         self.fear_greed_index = 50
         self.fear_greed_label = "Neutral"
         
@@ -60,95 +46,48 @@ class SmartPortfolio:
             "halt_reason": None
         }
         
-        print("💼 [SmartPortfolio V36.0] Regime-Aligned Risk System Initialized.")
+        print("💼 [SmartPortfolio V37.0] Grade-Based Sizing System Initialized.")
 
     async def initialize(self):
         await self._sync_state_from_r2()
         await self._check_daily_reset()
-        # تشغيل مراقب الخوف والجشع فقط (أما الاتجاه فيأتي من العقل المركزي)
         asyncio.create_task(self._market_monitor_loop())
 
-    # ==============================================================================
-    # 🦅 Market Monitor: Fear & Greed Only (Trend from Central)
-    # ==============================================================================
     async def _market_monitor_loop(self):
         """مراقبة مؤشر الخوف والجشع فقط"""
         print("🦅 [SmartPortfolio] Sentiment Sentinel Started.")
         async with httpx.AsyncClient() as client:
             while True:
                 try:
-                    # تحديث العرض بناءً على النظام المركزي
                     regime = getattr(SystemLimits, 'CURRENT_REGIME', 'RANGE')
-                    self.market_trend = regime # تحديث المتغير للعرض في الواجهة
+                    self.market_trend = regime
 
-                    # جلب مؤشر الخوف والجشع
                     try:
                         resp = await client.get("https://api.alternative.me/fng/?limit=1", timeout=10)
                         data = resp.json()
                         if data['data']:
                             self.fear_greed_index = int(data['data'][0]['value'])
                             self.fear_greed_label = data['data'][0]['value_classification']
-                    except Exception: 
-                        pass 
+                    except Exception: pass 
 
-                    await asyncio.sleep(300) # كل 5 دقائق
+                    await asyncio.sleep(300) 
                 except Exception as e:
                     print(f"⚠️ [Market Monitor] Error: {e}")
                     await asyncio.sleep(60)
 
     # ==============================================================================
-    # 🧮 The Consensus Engine
-    # ==============================================================================
-    def _calculate_composite_confidence(self, signal_data: Dict[str, Any]) -> float:
-        try:
-            l2_score = float(signal_data.get('enhanced_final_score', 0.5))
-            oracle_conf = float(signal_data.get('confidence', 0.5))
-            sniper_score = float(signal_data.get('sniper_score', 0.5))
-            
-            whale_impact = float(signal_data.get('whale_score', 0.0))
-            news_impact = float(signal_data.get('news_score', 0.0))
-            context_val = max(0.0, min(1.0, 0.5 + whale_impact + news_impact))
-            
-            # حساب سكور المزاج بناءً على Regime المركزي
-            regime = getattr(SystemLimits, 'CURRENT_REGIME', 'RANGE')
-            mood_score = 0.5
-            
-            if regime == "BULL": mood_score += 0.2
-            elif regime == "BEAR": mood_score -= 0.2
-            elif regime == "DEAD": mood_score -= 0.1
-                
-            # دمج F&G (Contrarian Logic)
-            fg = self.fear_greed_index
-            if fg < 20: mood_score += 0.1  # خوف شديد = شراء
-            elif fg > 80: mood_score -= 0.1 # جشع شديد = حذر
-            
-            mood_score = max(0.0, min(1.0, mood_score))
-
-            final_conf = (
-                (l2_score * self.WEIGHTS["L2_TECHNICAL"]) +
-                (oracle_conf * self.WEIGHTS["L3_ORACLE"]) +
-                (sniper_score * self.WEIGHTS["L4_SNIPER"]) +
-                (context_val * self.WEIGHTS["CONTEXT"]) +
-                (mood_score * self.WEIGHTS["MARKET_MOOD"])
-            )
-            return round(final_conf, 3)
-            
-        except Exception:
-            return float(signal_data.get('confidence', 0.5))
-
-    # ==============================================================================
-    # 🧠 Core Logic: Entry Approval (Regime-Adaptive Risk)
+    # 🧠 Core Logic: Entry Approval (Grade-Based)
     # ==============================================================================
     async def request_entry_approval(self, signal_data: Dict[str, Any], open_positions_count: int) -> Tuple[bool, Dict[str, Any]]:
         """
-        تطلب الموافقة مع مراعاة حالة السوق المركزية (Regime).
+        تطلب الموافقة وتحدد الحجم بناءً على جودة الحوكمة (Grade).
         """
         async with self.capital_lock:
             # 1. Circuit Breaker
             if self.state["is_trading_halted"]:
                 return False, {"reason": f"Halted: {self.state['halt_reason']}"}
 
-            # 2. Daily Loss Limit
+            # 2. Daily Loss Limit Check
             current_cap = float(self.state["current_capital"])
             start_cap = float(self.state["session_start_balance"])
             
@@ -159,76 +98,68 @@ class SmartPortfolio:
                 await self._save_state_to_r2()
                 return False, {"reason": "Daily Limit Hit"}
 
-            # 3. Regime-Based Slots & Risk
-            # قراءة الحالة من النظام المركزي
+            # ✅ 3. Governance Check (Quality Control)
+            gov_grade = signal_data.get('governance_grade', 'NORMAL')
+            gov_score = signal_data.get('governance_score', 50.0)
+
+            if gov_grade == 'REJECT':
+                return False, {"reason": f"Governance Rejected (Score: {gov_score})"}
+
+            # 4. Regime-Based Slots
             regime = getattr(SystemLimits, 'CURRENT_REGIME', 'RANGE')
             
-            # تحديد الحد الأقصى للصفقات بناءً على الحالة
-            if regime == "BULL":
-                max_slots = 6  # هجومي
-                risk_factor_base = 1.2
-            elif regime == "BEAR":
-                max_slots = 3  # دفاعي جداً
-                risk_factor_base = 0.5
-            elif regime == "DEAD":
-                max_slots = 2  # حذر جداً
-                risk_factor_base = 0.4
-            else: # RANGE
-                max_slots = 4  # متوازن
-                risk_factor_base = 0.8
+            if regime == "BULL": max_slots = 6 
+            elif regime == "BEAR": max_slots = 3 
+            elif regime == "DEAD": max_slots = 2 
+            else: max_slots = 4 
             
-            # تعديل للخزين الصغير
-            if current_cap < self.MIN_CAPITAL_FOR_SPLIT:
-                max_slots = min(max_slots, 2) # لا نفتح الكثير إذا الرصيد قليل
+            if current_cap < self.MIN_CAPITAL_FOR_SPLIT: max_slots = min(max_slots, 2)
 
             if open_positions_count >= max_slots:
                 return False, {"reason": f"Max slots reached for {regime} ({open_positions_count}/{max_slots})"}
 
-            # 4. Free Capital Check
+            # 5. Free Capital Check
             allocated = float(self.state.get("allocated_capital_usd", 0.0))
             free_capital = max(0.0, current_cap - allocated)
             
             if free_capital < 5.0:
                 return False, {"reason": f"Insufficient Free Capital (${free_capital:.2f})"}
 
-            # 5. Position Sizing
-            remaining_slots = max_slots - open_positions_count
-            base_allocation = 0.0
+            # ✅ 6. Position Sizing (Grade Logic)
+            # القاعدة: الحصة الكاملة = الكابيتال / عدد الخانات.
+            # الجودة تحدد كم نأخذ من هذه الحصة.
             
+            target_slot_size = 0.0
             if current_cap >= self.MIN_CAPITAL_FOR_SPLIT:
-                # تقسيم ذكي: نحاول الحفاظ على توازن، لكن نأخذ حصة أكبر في الـ Bull
-                target_size = current_cap / max_slots
-                base_allocation = min(target_size, free_capital)
+                target_slot_size = current_cap / max_slots
             else:
-                base_allocation = free_capital * 0.95 # All-in تقريباً للحسابات الصغيرة
+                target_slot_size = free_capital * 0.95 # All-in for small accounts
 
-            # 6. Consensus & Risk Multiplier
-            system_confidence = self._calculate_composite_confidence(signal_data)
-            
-            # تعديل المخاطرة بناءً على الثقة + الحالة
-            risk_multiplier = 1.0
-            if system_confidence >= 0.80: risk_multiplier = 1.2
-            elif system_confidence < 0.60: risk_multiplier = 0.7
-            
-            # دمج عامل الحالة (Regime Factor)
-            final_risk_mult = risk_multiplier * risk_factor_base
-            
-            final_size_usd = base_allocation * final_risk_mult
-            final_size_usd = min(final_size_usd, free_capital, current_cap * 0.98)
+            # مضاعف الجودة
+            quality_multiplier = 0.5 # Default NORMAL
+            if gov_grade == "ULTRA": quality_multiplier = 1.0   # 100% of slot
+            elif gov_grade == "STRONG": quality_multiplier = 0.75 # 75% of slot
+            elif gov_grade == "NORMAL": quality_multiplier = 0.50 # 50% of slot
+            elif gov_grade == "WEAK": quality_multiplier = 0.25   # 25% of slot
+
+            # حساب الحجم النهائي
+            final_size_usd = target_slot_size * quality_multiplier
+            final_size_usd = min(final_size_usd, free_capital) # لا نتجاوز المتوفر
 
             if final_size_usd < 5.0:
-                return False, {"reason": "Calculated size too small"}
+                # إذا كانت النسبة صغيرة جداً ولكن الحساب يسمح، نرفعها للحد الأدنى
+                if free_capital >= 5.0: final_size_usd = 5.0
+                else: return False, {"reason": "Calculated size too small"}
 
             # 7. Dynamic TP Selection
             entry_price = float(signal_data.get('sniper_entry_price') or signal_data.get('current_price'))
             tp_map = signal_data.get('tp_map', {})
             
-            # أهداف طموحة في Bull، ومحافظة في Bear
-            if regime == "BULL" and system_confidence >= 0.75:
+            if regime == "BULL" and gov_grade in ["STRONG", "ULTRA"]:
                 selected_tp = tp_map.get('TP3') or tp_map.get('TP4')
                 target_label = "TP3/4 (Bull Run)"
             elif regime == "BEAR":
-                selected_tp = tp_map.get('TP1') # خروج سريع في الهبوط
+                selected_tp = tp_map.get('TP1')
                 target_label = "TP1 (Scalp)"
             else:
                 selected_tp = tp_map.get('TP2')
@@ -240,9 +171,9 @@ class SmartPortfolio:
                 "approved_size_usd": float(final_size_usd),
                 "approved_tp": float(selected_tp),
                 "target_label": target_label,
-                "system_confidence": system_confidence,
-                "risk_multiplier": final_risk_mult,
-                "market_mood": f"{regime} | FG:{self.fear_greed_index}"
+                "system_confidence": gov_score / 100.0,
+                "risk_multiplier": quality_multiplier,
+                "market_mood": f"{regime} | Grade: {gov_grade}"
             }
 
     # ==============================================================================
@@ -264,7 +195,6 @@ class SmartPortfolio:
             self.state["current_capital"] += net_impact
             self.state["daily_net_pnl"] += net_impact
             
-            # Check Daily Limit after trade
             start = self.state["session_start_balance"]
             dd = (start - self.state["current_capital"]) / start if start > 0 else 0
             if dd >= self.DAILY_LOSS_LIMIT_PCT:
@@ -273,9 +203,6 @@ class SmartPortfolio:
             
             await self._save_state_to_r2()
 
-    # ==============================================================================
-    # 💾 Utilities
-    # ==============================================================================
     async def _check_daily_reset(self):
         last_reset = datetime.fromisoformat(self.state.get("last_session_reset", datetime.now().isoformat()))
         if datetime.now() - last_reset > timedelta(hours=24):