Update learning_hub/hub_manager.py

learning_hub/hub_manager.py

@@ -1,181 +1,157 @@
 # learning_hub/hub_manager.py
-# (V4.3 - NO_LLM toggle, auto-disable if llm_service is None, zero LLM calls)
+# (محدث بالكامل - V4 - Adaptive Hybrid Weights Support)
 
-import os
 import asyncio
-from typing import Any, Dict
+import traceback
+from typing import Any, Dict, List
 from datetime import datetime, timezone
 from collections import defaultdict
 
-# مكونات المشروع
+# (استيراد جميع المكونات الداخلية للمركز)
+from .schemas import *
 from .policy_engine import PolicyEngine
 from .memory_store import MemoryStore
 from .statistical_analyzer import StatisticalAnalyzer
 from .reflector import Reflector
 from .curator import Curator
 
-# (اختياري) تعلم الحيتان
+# استيراد لتحليل الارتباط (Whale Learning)
 try:
     import numpy as np
     from scipy.stats import pearsonr
     NUMPY_AVAILABLE = True
-except Exception:
-    print("❌ [HubManager] numpy/scipy غير متوفرين. تعطيل تعلم الحيتان المتقدم.", flush=True)
+except ImportError:
+    print("❌ [HubManager] مكتبة numpy أو scipy غير مثبتة! لن يعمل تعلم الحيتان.")
     NUMPY_AVAILABLE = False
 
-
 class LearningHubManager:
-    def __init__(self, r2_service: Any, llm_service: Any, data_manager: Any, disable_llm: bool = None):
-        """
-        تبديل مؤقت لتعطيل LLM:
-          - disable_llm=True ⇒ تعطيل كامل.
-          - disable_llm=None ⇒ يُقرأ من NO_LLM.
-          - إذا llm_service هو None ⇒ يُعطل تلقائياً حتى لو كان NO_LLM غير مفعّل.
-        """
-        env_flag = os.getenv("NO_LLM", "").strip().lower() in ("1", "true", "yes", "on")
-        user_flag = bool(disable_llm) if disable_llm is not None else False
-        auto_flag = (llm_service is None)
-        self.llm_disabled = env_flag or user_flag or auto_flag
-
-        print("🚀 Initializing Learning Hub Manager (V4.3 - NO_LLM toggle + auto-disable)...", flush=True)
-
-        # الخدمات الأساسية
+    def __init__(self, r2_service: Any, llm_service: Any, data_manager: Any):
+        print("🚀 Initializing Learning Hub Manager (V4 - Adaptive)...")
+        
+        # 1. الخدمات الأساسية
         self.r2_service = r2_service
-        self.llm_service = None if self.llm_disabled else llm_service
+        self.llm_service = llm_service
         self.data_manager = data_manager
 
-        # المكونات الجوهرية
+        # 2. تهيئة المكونات
         self.policy_engine = PolicyEngine()
         self.memory_store = MemoryStore(
-            r2_service=self.r2_service,
+            r2_service=self.r2_service, 
             policy_engine=self.policy_engine,
-            llm_service=(None if self.llm_disabled else self.llm_service)
+            llm_service=self.llm_service 
         )
-
-        # Reflector/Curator تُنشأ فقط عند تفعيل LLM فعلياً
-        self.reflector = None if self.llm_disabled else Reflector(
+        self.reflector = Reflector(
             llm_service=self.llm_service,
             memory_store=self.memory_store
         )
-        self.curator = None if self.llm_disabled else Curator(
+        self.curator = Curator(
             llm_service=self.llm_service,
             memory_store=self.memory_store
         )
-
-        # الإحصاء يعمل دائماً
         self.statistical_analyzer = StatisticalAnalyzer(
             r2_service=self.r2_service,
             data_manager=self.data_manager
         )
-
-        # تعلم الحيتان
+        
+        # متغيرات حالة لتعلم الحيتان
         self.whale_learning_lock = asyncio.Lock()
-        self.optimal_whale_config: Dict[str, Any] = {}
-
+        self.optimal_whale_config = {}
+        
         self.initialized = False
-        print("✅ Learning Hub Manager constructed. Ready for initialization.", flush=True)
-        print(f"ℹ️ [HubManager] LLM mode: {'DISABLED' if self.llm_disabled else 'ENABLED'}", flush=True)
+        print("✅ Learning Hub Manager constructed. Ready for initialization.")
 
     async def initialize(self):
-        if self.initialized:
-            return
-        print("🔄 [HubManager] Initializing all sub-modules...", flush=True)
-
+        """تهيئة جميع الأنظمة الفرعية"""
+        if self.initialized: return
+        print("🔄 [HubManager] Initializing all sub-modules...")
+        
+        # تهيئة المحلل الإحصائي (المسؤول عن الأوزان المتكيفة)
         await self.statistical_analyzer.initialize()
-
+        
+        # تحميل إعدادات تعلم الحيتان
         if hasattr(self.r2_service, 'load_whale_learning_config_async'):
-            try:
-                self.optimal_whale_config = await self.r2_service.load_whale_learning_config_async()
-                if self.optimal_whale_config:
-                    bm = self.optimal_whale_config.get('best_metric', 'N/A')
-                    print(f"✅ [HubManager] Loaded optimal whale config: {bm}", flush=True)
-            except Exception as e:
-                print(f"⚠️ [HubManager] load_whale_learning_config_async failed: {e}", flush=True)
-
+            self.optimal_whale_config = await self.r2_service.load_whale_learning_config_async()
+            if self.optimal_whale_config:
+                print(f"✅ [HubManager] Loaded optimal whale config: {self.optimal_whale_config.get('best_metric', 'N/A')}")
+        
         self.initialized = True
-        state = "NO_LLM" if self.llm_disabled else "LLM_ENABLED"
-        print(f"✅ [HubManager] All sub-modules initialized. Learning Hub is LIVE ({state}).", flush=True)
+        print("✅ [HubManager] All sub-modules initialized. Learning Hub is LIVE.")
 
     async def analyze_trade_and_learn(self, trade_object: Dict[str, Any], close_reason: str):
-        if not self.initialized:
-            return
+        """الدالة الرئيسية للتعلم من الصفقات المغلقة"""
+        if not self.initialized: return
 
-        print(f"🧠 [HubManager] Learning from trade {trade_object.get('symbol')}...", flush=True)
+        print(f"🧠 [HubManager] Learning from trade {trade_object.get('symbol')}...")
 
-        # Reflector: ممنوع النداء إذا كان LLM معطلاً أو الخدمة غير متاحة
-        if not self.llm_disabled and self.reflector is not None and self.llm_service is not None and hasattr(self.llm_service, "_call_llm"):
-            try:
-                await self.reflector.analyze_trade_outcome(trade_object, close_reason)
-            except Exception as e:
-                print(f"❌ [HubManager] Reflector failed: {e}", flush=True)
-        else:
-            print("ℹ️ [HubManager] Reflector skipped (NO_LLM).", flush=True)
+        # 1. التعلم السريع (Reflector)
+        try:
+            await self.reflector.analyze_trade_outcome(trade_object, close_reason)
+        except Exception as e:
+            print(f"❌ [HubManager] Reflector failed: {e}")
 
-        # التحليل الإحصائي وتكييف الأوزان
+        # 2. التعلم البطيء وتكييف الأوزان (StatisticalAnalyzer)
         try:
             await self.statistical_analyzer.update_statistics(trade_object, close_reason)
         except Exception as e:
-            print(f"❌ [HubManager] StatisticalAnalyzer failed: {e}", flush=True)
-
-        print(f"✅ [HubManager] Learning complete for {trade_object.get('symbol')}.", flush=True)
+            print(f"❌ [HubManager] StatisticalAnalyzer failed: {e}")
+            
+        print(f"✅ [HubManager] Learning complete for {trade_object.get('symbol')}.")
 
     async def get_optimized_weights(self, market_condition: str = None) -> Dict[str, Any]:
+        """
+        جلب الأوزان المحسنة (بما في ذلك الأوزان الهجينة المتكيفة).
+        يستخدمها MLProcessor لتحديث معادلته الهجينة.
+        """
         if not self.initialized:
-            return await self.statistical_analyzer.get_default_strategy_weights()
+             return await self.statistical_analyzer.get_default_strategy_weights()
+
+        # إرجاع قاموس الأوزان الكامل من المحلل الإحصائي
         return self.statistical_analyzer.weights
 
-    # واجهات LLM تبقى موجودة للتوافق ولكنها تُرجع رسالة عند التعطيل
+    # --- دوال مساعدة أخرى (للـ LLM وغيرها) ---
     async def get_active_context_for_llm(self, domain: str, query: str) -> str:
-        if self.llm_disabled:
-            return "LLM disabled by configuration (NO_LLM)."
-        if not self.initialized:
-            return "Learning Hub not initialized."
+        if not self.initialized: return "Learning Hub not initialized."
         return await self.memory_store.get_active_context(domain, query)
-
+        
     async def get_statistical_feedback_for_llm(self, entry_strategy: str) -> str:
-        if self.llm_disabled:
-            return "LLM disabled by configuration (NO_LLM)."
-        if not self.initialized:
-            return "Learning Hub not initialized."
+        if not self.initialized: return "Learning Hub not initialized."
         best_profile = await self.statistical_analyzer.get_best_exit_profile(entry_strategy)
         if best_profile != "unknown":
             return f"Statistical Feedback: For '{entry_strategy}', '{best_profile}' exit profile performed best."
         return "No statistical feedback available yet."
 
+    async def get_statistical_news_score(self, raw_vader_score: float) -> float:
+        if not self.initialized: return 0.0
+        return await self.statistical_analyzer.get_statistical_vader_pnl(raw_vader_score)
+
     async def run_distillation_check(self):
-        if not self.initialized or self.llm_disabled or self.curator is None:
-            return
+        """تشغيل دوري للتقطير (Curator)"""
+        if not self.initialized: return
+        # print("ℹ️ [HubManager] Running distillation check...")
         for domain in self.memory_store.domain_files.keys():
-            try:
-                await self.curator.check_and_distill_domain(domain)
-            except Exception:
-                pass
+            await self.curator.check_and_distill_domain(domain)
 
     async def shutdown(self):
-        if not self.initialized:
-            return
-        print("🔄 [HubManager] Shutting down... Saving learning data.", flush=True)
+        """حفظ كل البيانات عند الإغلاق"""
+        if not self.initialized: return
+        print("🔄 [HubManager] Shutting down... Saving learning data.")
         try:
+            # المحلل الإحصائي يحفظ الأوزان المتكيفة وسجل الأداء
             await self.statistical_analyzer.save_weights_to_r2()
             await self.statistical_analyzer.save_performance_history()
             await self.statistical_analyzer.save_exit_profile_effectiveness()
             await self.statistical_analyzer.save_vader_effectiveness()
-            print("✅ [HubManager] Data saved successfully.", flush=True)
+            print("✅ [HubManager] Data saved successfully.")
         except Exception as e:
-            print(f"❌ [HubManager] Save failed: {e}", flush=True)
+            print(f"❌ [HubManager] Save failed: {e}")
 
-    # --- Whale Learning Loop (لا يعتمد على LLM) ---
+    # --- Whale Learning Loop (كما هي من V3) ---
     async def run_whale_learning_check(self):
-        if not self.initialized:
-            await asyncio.sleep(60)
-        print("🧠 [Whale-Logger] Starting background learning loop...", flush=True)
-        await asyncio.sleep(600)
+        if not self.initialized: await asyncio.sleep(60)
+        print(f"🧠 [Whale-Logger] Starting background learning loop...")
+        await asyncio.sleep(600) 
         while True:
             try:
-                if not hasattr(self.r2_service, 'get_pending_whale_learning_records_async'):
-                    await asyncio.sleep(600)
-                    continue
-
                 pending = await self.r2_service.get_pending_whale_learning_records_async()
                 if not pending:
                     await asyncio.sleep(600)
@@ -186,49 +162,34 @@ class LearningHubManager:
                     try:
                         target_time = datetime.fromisoformat(record['target_time_utc'])
                         if now_utc >= target_time:
-                            symbol = record.get('symbol')
-                            if hasattr(self.data_manager, 'get_latest_price_async'):
-                                target_price = await self.data_manager.get_latest_price_async(symbol)
-                            else:
-                                target_price = None
-
-                            if target_price and target_price > 0 and record.get('start_price_usd', 0) > 0:
+                            symbol = record['symbol']
+                            target_price = await self.data_manager.get_latest_price_async(symbol)
+                            if target_price and target_price > 0 and record['start_price_usd'] > 0:
                                 pct_change = ((target_price - record['start_price_usd']) / record['start_price_usd']) * 100
-                                record.update({
-                                    'target_price_usd': target_price,
-                                    'price_change_percentage': pct_change,
-                                    'status': "COMPLETED"
-                                })
-                                if hasattr(self.r2_service, 'update_completed_whale_learning_record_async'):
-                                    await self.r2_service.update_completed_whale_learning_record_async(record)
-                    except Exception:
-                        pass
-
+                                record.update({'target_price_usd': target_price, 'price_change_percentage': pct_change, 'status': "COMPLETED"})
+                                await self.r2_service.update_completed_whale_learning_record_async(record)
+                    except Exception: pass
+                
                 await self.update_optimal_whale_window()
-                await asyncio.sleep(300)
+                await asyncio.sleep(300) 
             except Exception as e:
-                print(f"❌ [Whale-Logger] Error: {e}", flush=True)
+                print(f"❌ [Whale-Logger] Error: {e}")
                 await asyncio.sleep(600)
 
     async def update_optimal_whale_window(self):
-        if not NUMPY_AVAILABLE:
-            return
+        if not NUMPY_AVAILABLE: return
         async with self.whale_learning_lock:
             try:
-                if not hasattr(self.r2_service, 'get_all_completed_whale_records_async'):
-                    return
                 all_completed = await self.r2_service.get_all_completed_whale_records_async()
-                if not all_completed or len(all_completed) < 20:
-                    return
+                if len(all_completed) < 20: return
 
                 price_changes = []
                 metrics_data = defaultdict(lambda: defaultdict(list))
                 windows = ['30m', '1h', '2h', '4h', '24h']
                 metric_keys = ['relative_net_flow_percent', 'transaction_density', 'net_flow_usd']
-
+                
                 for r in all_completed:
-                    if r.get('price_change_percentage') is None:
-                        continue
+                    if r.get('price_change_percentage') is None: continue
                     price_changes.append(r['price_change_percentage'])
                     analysis = r.get('window_analysis', {})
                     for w in windows:
@@ -236,33 +197,24 @@ class LearningHubManager:
                             metrics_data[w][k].append(analysis.get(w, {}).get(k, 0.0))
 
                 price_np = np.array(price_changes)
-                best_corr = 0.0
+                best_corr = 0
                 best_key = None
 
                 for w in windows:
                     for k in metric_keys:
                         metric_np = np.array(metrics_data[w][k])
-                        if len(metric_np) == len(price_np) and len(price_np) > 0:
-                            try:
-                                corr, p_val = pearsonr(metric_np, price_np)
-                            except Exception:
-                                continue
+                        if len(metric_np) == len(price_np):
+                            corr, p_val = pearsonr(metric_np, price_np)
                             if not np.isnan(corr) and p_val < 0.1 and abs(corr) > best_corr:
-                                best_corr = float(abs(corr))
+                                best_corr = abs(corr)
                                 best_key = f"{w}_{k}"
 
                 if best_key:
                     w, m = best_key.split('_', 1)
-                    new_config = {
-                        "best_window": w,
-                        "best_metric": m,
-                        "correlation_score": best_corr,
-                        "total_samples": int(len(price_np)),
-                        "last_updated_utc": datetime.now(timezone.utc).isoformat()
-                    }
+                    new_config = {"best_window": w, "best_metric": m, "correlation_score": best_corr, "total_samples": len(price_np), "last_updated_utc": datetime.now(timezone.utc).isoformat()}
                     self.optimal_whale_config = new_config
-                    if hasattr(self.r2_service, 'save_whale_learning_config_async'):
-                        await self.r2_service.save_whale_learning_config_async(new_config)
-                    print(f"🏆 [Whale-Teacher] New best signal: {m} on {w} (Corr: {best_corr:.2f})", flush=True)
+                    await self.r2_service.save_whale_learning_config_async(new_config)
+                    print(f"🏆 [Whale-Teacher] New best signal: {m} on {w} (Corr: {best_corr:.2f})")
+
             except Exception as e:
-                print(f"❌ [Whale-Teacher] Error: {e}", flush=True)
+                print(f"❌ [Whale-Teacher] Error: {e}")