Update app.py

app.py

@@ -1,107 +1,212 @@
-# app.py (V12.3 - Hybrid Orchestrator with Correct Naming)
-import os
-import traceback
-import signal
-import sys
-import uvicorn
-import asyncio
-import json
-import gc
-import time
+# app.py (V14.0 - Unified Smart Cycle - Full Production Version)
+import os, sys, traceback, asyncio, gc, json
+from datetime import datetime
 from contextlib import asynccontextmanager
 from fastapi import FastAPI, HTTPException, BackgroundTasks
-from datetime import datetime
-from typing import List, Dict, Any
 
+# --- استيراد الوحدات الأساسية ---
 try:
     from r2 import R2Service
-    from LLM import LLMService
     from data_manager import DataManager
     from ml_engine.processor import MLProcessor
-    from learning_hub.hub_manager import LearningHubManager
     from trade_manager import TradeManager
+    from LLM import LLMService
+    from learning_hub.hub_manager import LearningHubManager
+    # وحدات الطبقة الثانية
+    from whale_monitor.core import EnhancedWhaleMonitor
+    from sentiment_news import NewsFetcher
+    from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
 except ImportError as e:
-    sys.exit(f"❌ Fatal Error: {e}")
+    # إيقاف النظام في حال فشل استيراد أي مكون حيوي
+    sys.exit(f"❌ Fatal Init Error: {e}")
 
-r2_service_global = None
-data_manager_global = None
-llm_service_global = None
-learning_hub_global = None
-trade_manager_global = None
-ml_processor_global = None
+# --- المتغيرات العامة (Global Instances) ---
+r2 = None
+data_manager = None
+ml_processor = None
+trade_manager = None
+llm_service = None
+learning_hub = None
+whale_monitor = None
+news_fetcher = None
+vader = None
 
-class StateManager:
+class SystemState:
     def __init__(self):
-        self.initialization_complete = False
-        self.services_initialized = {}
-
-    def set_service_initialized(self, service_name):
-        self.services_initialized[service_name] = True
-        if len(self.services_initialized) >= 5:
-            self.initialization_complete = True
-            print("🎯 [System] All services initialized. Ready for external triggers.")
+        self.ready = False
+        self.cycle_running = False
 
-state_manager = StateManager()
+sys_state = SystemState()
 
-async def initialize_services():
-    global r2_service_global, data_manager_global, llm_service_global
-    global learning_hub_global, trade_manager_global, ml_processor_global
+# ==============================================================================
+# 🚀 تهيئة النظام الكاملة (Full System Initialization)
+# ==============================================================================
+async def initialize_system():
+    global r2, data_manager, ml_processor, trade_manager, llm_service, learning_hub
+    global whale_monitor, news_fetcher, vader
+    
+    if sys_state.ready: return
+    print("\n🔌 [System V14] Initializing Smart Core...")
     
     try:
-        print("🚀 [System V12.3] Starting Hybrid Initialization...")
-        r2_service_global = R2Service()
-        state_manager.set_service_initialized('r2')
+        # 1. الخدمات الأساسية والبنية التحتية
+        r2 = R2Service()
+        contracts = await r2.load_contracts_db_async()
+        
+        whale_monitor = EnhancedWhaleMonitor(contracts_db=contracts, r2_service=r2)
+        data_manager = DataManager(contracts, whale_monitor, r2)
+        await data_manager.initialize()
+        
+        news_fetcher = NewsFetcher()
+        vader = SentimentIntensityAnalyzer()
+        
+        # 2. العقل المركزي (LLM) ومحور التعلم
+        llm_service = LLMService()
+        llm_service.r2_service = r2 # لربط حفظ البرومبتات
+        # سيتم ربط learning_hub لاحقاً لتجنب التبعية الدائرية
+        
+        learning_hub = LearningHubManager(r2, llm_service, data_manager)
+        await learning_hub.initialize()
+        llm_service.learning_hub = learning_hub # الربط العكسي
+
+        # 3. محركات التحليل والتنفيذ
+        ml_processor = MLProcessor(None, data_manager, learning_hub)
+        await ml_processor.initialize()
+
+        trade_manager = TradeManager(r2, data_manager, ml_processor.titan, ml_processor.pattern_analyzer)
+        await trade_manager.initialize_sentry_exchanges()
+        # بدء حلقات المراقبة الخلفية للحارس
+        asyncio.create_task(trade_manager.start_sentry_loops())
+
+        sys_state.ready = True
+        print("✅ [System] All Systems GO. Ready for action.")
         
-        contracts_db = await r2_service_global.load_contracts_db_async() or {}
-        data_manager_global = DataManager(contracts_db, None, r2_service_global)
-        await data_manager_global.initialize()
-        state_manager.set_service_initialized('data')
-
-        llm_service_global = LLMService()
-        llm_service_global.r2_service = r2_service_global
-        learning_hub_global = LearningHubManager(r2_service_global, llm_service_global, data_manager_global)
-        await learning_hub_global.initialize()
-        state_manager.set_service_initialized('hub')
-
-        ml_processor_global = MLProcessor(None, data_manager_global, learning_hub_global)
-        await ml_processor_global.initialize()
-        state_manager.set_service_initialized('processor')
-
-        trade_manager_global = TradeManager(
-            r2_service_global, 
-            data_manager_global, 
-            titan_engine=ml_processor_global.titan,
-            # تمرير المعالج بالكامل للوصول إلى التقييم الهجين لاحقاً إذا احتجنا
-            processor=ml_processor_global 
-        )
-        await trade_manager_global.initialize_sentry_exchanges()
-        state_manager.set_service_initialized('trade')
-
-        return True
     except Exception as e:
-        print(f"❌ [Init Error] {e}")
+        print(f"❌ [Init Failed] {e}")
         traceback.print_exc()
-        return False
+        sys.exit(1) # خروج اضطراري في حال فشل التهيئة
 
-async def run_explorer_cycle():
-    if not state_manager.initialization_complete: 
-        print("⏳ [Cycle Skipped] System still initializing...")
+# ==============================================================================
+# 🧠 الدورة الموحدة الذكية (Unified Smart Cycle Entry Point)
+# ==============================================================================
+async def run_unified_cycle():
+    """
+    نقطة الدخول الوحيدة للدورات.
+    تقرر تلقائياً بين وضع 'البحث عن فرص' ووضع 'إدارة الصفقات المفتوحة'.
+    """
+    if not sys_state.ready:
+        print("⏳ [Cycle Skipped] System not ready yet.")
+        return
+    if sys_state.cycle_running:
+        print("⏳ [Cycle Skipped] Another cycle is already running.")
         return
 
-    print(f"\n🔭 [Explorer V12.3] Cycle started at {datetime.now().strftime('%H:%M:%S')}")
+    # محاولة الحصول على القفل لمنع تداخل العمليات
+    if not r2.acquire_lock():
+        print("🔒 [Cycle Skipped] Locked by another process.")
+        return
+
+    sys_state.cycle_running = True
+    start_time = datetime.now()
     
     try:
-        candidates = await data_manager_global.layer1_rapid_screening()
-        if not candidates: 
-            print("😴 [Explorer] No candidates found in Layer 1.")
-            return
+        # فحص حالة الحارس: هل هناك صفقات نشطة؟
+        open_trades = list(trade_manager.open_positions.values())
+        
+        if open_trades:
+            # --- 🛡️ الفرع الاستراتيجي: وضع إعادة التقييم ---
+            print(f"\n⚔️ [Unified Cycle] Active trades detected ({len(open_trades)}). Engaging STRATEGIC RE-ANALYSIS mode.")
+            await _run_reanalysis_mode(open_trades)
+        else:
+            # --- 🔭 فرع المستكشف: وضع البحث عن فرص ---
+            print("\n🔭 [Unified Cycle] No active trades. Engaging EXPLORER mode.")
+            await _run_explorer_mode()
+
+    except Exception as e:
+        print(f"❌ [Cycle Error] An unexpected error occurred: {e}")
+        traceback.print_exc()
+    finally:
+        # تنظيف وإطلاق القفل دائماً
+        r2.release_lock()
+        sys_state.cycle_running = False
+        gc.collect() # تنظيف الذاكرة
+        print(f"🏁 [Cycle Finished] Duration: {(datetime.now() - start_time).total_seconds():.1f}s")
 
-        print(f"🔬 [Titan Hybrid] analyzing {len(candidates)} candidates...")
-        titan_candidates = []
-        all_scored_debug = []
+# ==============================================================================
+# 🛡️ الفرع 1: وضع إعادة التقييم الاستراتيجي (Strategic Re-analysis Mode)
+# ==============================================================================
+async def _run_reanalysis_mode(open_trades):
+    """إعادة تقييم جميع الصفقات المفتوحة باستخدام العقل الكلي"""
+    for trade in open_trades:
+        symbol = trade['symbol']
+        print(f"   ⚖️  Re-evaluating {symbol} with Omniscient Brain...")
         
-        data_queue = asyncio.Queue(maxsize=10)
-        producer = asyncio.create_task(data_manager_global.stream_ohlcv_data(candidates, data_queue))
+        try:
+            # 1. جمع البيانات الطازجة (Fresh Data Snapshot)
+            current_price = await data_manager.get_latest_price_async(symbol)
+            whale_data = await whale_monitor.get_symbol_whale_activity(symbol)
+            news_text = await news_fetcher.get_news_for_symbol(symbol)
+            
+            # محاولة الحصول على تحديث سريع لدرجة تيتان (اختياري، يعتمد على توفر البيانات)
+            # هنا نستخدم 0 كقيمة افتراضية إذا لم نتمكن من إجراء تحليل كامل سريعاً
+            titan_score = 0.0 
+
+            current_data_packet = {
+                'symbol': symbol,
+                'current_price': current_price,
+                'titan_score': titan_score,
+                'whale_data': whale_data,
+                'news_text': news_text
+            }
+            
+            # 2. استشارة العقل الكلي (Omniscient Brain Consultation)
+            decision = await llm_service.re_analyze_trade_async(trade, current_data_packet)
+            
+            # 3. تنفيذ أوامر العقل فوراً
+            if decision:
+                action = decision.get('action')
+                reason = decision.get('reasoning', 'Strategic update by Brain')
+                
+                if action == 'EMERGENCY_EXIT':
+                    print(f"      🚨 BRAIN COMMAND: IMMEDIATE EMERGENCY EXIT for {symbol}!")
+                    await trade_manager.execute_emergency_exit(symbol, f"Brain Command: {reason}")
+                    
+                elif action == 'UPDATE_TARGETS':
+                    new_tp = decision.get('new_tp')
+                    new_sl = decision.get('new_sl')
+                    if new_tp or new_sl:
+                        print(f"      🎯 BRAIN COMMAND: Update targets for {symbol} (TP: {new_tp}, SL: {new_sl})")
+                        await trade_manager.update_trade_targets(symbol, new_tp, new_sl, f"Brain Update: {reason}")
+                    else:
+                         print(f"      ⚠️ Brain requested target update for {symbol} but provided no values.")
+                else:
+                    # HOLD or unknown action
+                    print(f"      ✅ Brain verdict for {symbol}: HOLD. Continuing strategy. ({reason[:50]}...)")
+            else:
+                print(f"      ⚠️ Failed to get a valid re-analysis decision from Brain for {symbol}.")
+
+        except Exception as e:
+            print(f"      ❌ Error re-evaluating {symbol}: {e}")
+
+# ==============================================================================
+# 🔭 الفرع 2: وضع المستكشف (The 4-Layer Explorer Mode)
+# ==============================================================================
+async def _run_explorer_mode():
+    """تنفيذ دورة البحث الكاملة عبر الطبقات الأربع"""
+    try:
+        # ---------------------------------------------------------
+        # Layer 1: Rapid Hybrid Screening (Titan + Patterns + Simple MC)
+        # ---------------------------------------------------------
+        print("\n--- 🛡️ Layer 1: Rapid Screening ---")
+        raw_candidates = await data_manager.layer1_rapid_screening()
+        if not raw_candidates:
+            print("   ⚠️ No initial candidates found in Layer 1.")
+            return
+
+        l1_passed = []
+        data_queue = asyncio.Queue()
+        # بدء بث البيانات ومعالجتها بالتوازي
+        producer = asyncio.create_task(data_manager.stream_ohlcv_data(raw_candidates, data_queue))
         
         while True:
             batch = await data_queue.get()
@@ -110,74 +215,142 @@ async def run_explorer_cycle():
                 break
             
             for raw_data in batch:
-                res = await ml_processor_global.process_and_score_symbol_enhanced(raw_data)
-                if res:
-                     score = res.get('enhanced_final_score', 0.0)
-                     all_scored_debug.append(res)
-                     
-                     # استخدام العتبة الهجينة الجديدة
-                     if score >= data_manager_global.HYBRID_ENTRY_THRESHOLD:
-                          print(f"   🌟 [Hybrid Approved] {res['symbol']} Score: {score:.4f}")
-                          titan_candidates.append(res)
+                # المعالجة الأولية باستخدام MLProcessor
+                res = await ml_processor.process_and_score_symbol_enhanced(raw_data)
+                # عتبة مرور أولية مخففة (مثلاً 0.50) للسماح بمرور عدد كافٍ للطبقة الثانية
+                if res and res.get('enhanced_final_score', 0.0) >= 0.50:
+                    l1_passed.append(res)
             
             data_queue.task_done()
         await producer
+        
+        # ترتيب واختيار أفضل 10 فقط للتحليل العميق
+        l1_passed.sort(key=lambda x: x['enhanced_final_score'], reverse=True)
+        layer2_candidates = l1_passed[:10]
+        print(f"✅ Layer 1 Complete. {len(layer2_candidates)} candidates advanced to Layer 2.")
+
+        if not layer2_candidates: return
 
-        if titan_candidates:
-            titan_candidates.sort(key=lambda x: x['enhanced_final_score'], reverse=True)
-            top_picks = titan_candidates[:5]
-            print(f"✅ [Explorer] Sending {len(top_picks)} to Sentry.")
-            await trade_manager_global.update_sentry_watchlist(top_picks)
+        # ---------------------------------------------------------
+        # Layer 2: Deep Analysis (Whales + News + Advanced MC)
+        # ---------------------------------------------------------
+        print("\n--- 🐳 Layer 2: Deep Analysis ---")
+        l2_scored = []
+        for cand in layer2_candidates:
+            symbol = cand['symbol']
+            print(f"   🔎 Deep analyzing {symbol}...")
+            
+            # A. تحليل الحيتان
+            whale_data = await whale_monitor.get_symbol_whale_activity(symbol)
+            
+            # B. تحليل الأخبار والمشاعر
+            news_text = await news_fetcher.get_news_for_symbol(symbol)
+            # تحليل VADER بسيط للمساعدة في الترتيب الأولي (النموذج الضخم سيقرأ النص الخام لاحقاً)
+            news_score = vader.polarity_scores(news_text)['compound'] if news_text else 0.0
+            
+            # C. حساب "النقاط المعززة" (Enhanced Score) لترتيب المرشحين
+            # المعادلة: 50% درجة الطبقة الأولى + 30% بونص حيتان + 20% بونص أخبار
+            l1_score = cand['enhanced_final_score']
+            whale_bonus = 0.15 if whale_data.get('trading_signal', {}).get('action') in ['BUY', 'STRONG_BUY'] else 0.0
+            news_bonus = 0.10 if news_score > 0.25 else (-0.10 if news_score < -0.25 else 0.0)
+            
+            final_l2_score = min(1.0, max(0.0, l1_score + whale_bonus + news_bonus))
+            
+            # تحديث سجل المرشح بكل البيانات الجديدة (ليراها النموذج الضخم)
+            cand.update({
+                'layer2_score': final_l2_score,
+                'whale_data': whale_data,
+                'news_text': news_text,
+                'news_score_raw': news_score
+            })
+            l2_scored.append(cand)
+
+        # اختيار أفضل 5 للطبقة الثالثة
+        l2_scored.sort(key=lambda x: x['layer2_score'], reverse=True)
+        layer3_candidates = l2_scored[:5]
+        print(f"✅ Layer 2 Complete. Top 5 candidates selected for Brain validation.")
+
+        # ---------------------------------------------------------
+        # Layer 3: The Brain Filter (LLM Validation)
+        # ---------------------------------------------------------
+        print("\n--- 🧠 Layer 3: Omniscient Brain Validation ---")
+        approved_targets = []
+        for cand in layer3_candidates:
+            symbol = cand['symbol']
+            print(f"   ⚖️  Consulting Brain for {symbol}...")
+            
+            # استشارة العقل الكلي بوجبة البيانات الكاملة
+            decision = await llm_service.get_trading_decision(cand)
+            
+            if decision and decision.get('action') == 'WATCH':
+                confidence = decision.get('confidence_level', 0)
+                print(f"      🎉 APPROVED by Brain! Confidence: {confidence:.2f}")
+                cand['llm_decision'] = decision
+                approved_targets.append(cand)
+            else:
+                reason = decision.get('reasoning', 'Unknown reason') if decision else 'Brain Consultation Failed'
+                print(f"      🛑 REJECTED by Brain: {reason[:60]}...")
+
+        # ---------------------------------------------------------
+        # Layer 4: Active Sentry Handover
+        # ---------------------------------------------------------
+        print("\n--- 🛡️ Layer 4: Sentry Handover ---")
+        if approved_targets:
+            print(f"🚀 Handing over {len(approved_targets)} elite targets to Sentry for tactical execution.")
+            await trade_manager.update_sentry_watchlist(approved_targets)
         else:
-            print("📉 [Explorer] No candidates met the Hybrid Threshold this cycle.")
-            if all_scored_debug:
-                print(f"\n🔍 [Debug] أفضل 10 مرفوضين (العتبة الهجينة: {data_manager_global.HYBRID_ENTRY_THRESHOLD}):")
-                all_scored_debug.sort(key=lambda x: x.get('enhanced_final_score', 0.0), reverse=True)
-                for i, cand in enumerate(all_scored_debug[:10]):
-                     final = cand.get('enhanced_final_score', 0.0)
-                     comps = cand.get('components', {})
-                     t_s = comps.get('titan_score', 0.0)
-                     p_s = comps.get('patterns_score', 0.0)
-                     m_s = comps.get('mc_score', 0.0)
-                     print(f"   #{i+1} {cand['symbol']:<10}: {final:.4f} [🐺Titan:{t_s:.2f} | 📊Pat:{p_s:.2f} | 🎲MC:{m_s:.2f}]")
-            print("-" * 60)
+            print("😴 No candidates passed all 4 layers this cycle. Sentry remains on standby.")
 
     except Exception as e:
-        print(f"❌ [Cycle Error] {e}")
-        traceback.print_exc()
-    finally:
-        gc.collect()
+         print(f"❌ [Explorer Mode Error] {e}")
+         traceback.print_exc()
 
+# ==============================================================================
+# 🔥 تطبيق FastAPI (نقاط النهاية)
+# ==============================================================================
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    asyncio.create_task(initialize_services())
+    # تهيئة النظام عند البدء
+    await initialize_system()
     yield
-    if trade_manager_global: await trade_manager_global.stop_sentry_loops()
-    if data_manager_global: await data_manager_global.close()
-    print("👋 [System] Shutdown complete.")
+    # تنظيف الموارد عند الإغلاق
+    if trade_manager: await trade_manager.stop_sentry_loops()
+    if data_manager: await data_manager.close()
+    print("👋 System Shutdown Gracefully.")
 
-app = FastAPI(lifespan=lifespan, title="Titan Hybrid Trading Bot V12.3")
+app = FastAPI(lifespan=lifespan, title="Titan 4-Layer Hybrid System V14")
 
 @app.get("/")
-async def root():
-    return {"status": "Hybrid System Online", "initialized": state_manager.initialization_complete}
+def root():
+    return {
+        "status": "Smart Hybrid System Online",
+        "initialized": sys_state.ready,
+        "mode": "Re-analysis" if trade_manager and trade_manager.open_positions else "Explorer"
+    }
 
 @app.get("/run-cycle")
 async def trigger_cycle(background_tasks: BackgroundTasks):
-    if not state_manager.initialization_complete:
-        raise HTTPException(status_code=503, detail="System initializing...")
-    background_tasks.add_task(run_explorer_cycle)
-    return {"message": "Hybrid cycle triggered"}
+    """نقطة الاستدعاء الخارجية (مثلاً كل 15 دقيقة)"""
+    if not sys_state.ready:
+        raise HTTPException(status_code=503, detail="System is still initializing...")
+    
+    # إضافة الدورة الموحدة إلى مهام الخلفية
+    background_tasks.add_task(run_unified_cycle)
+    return {"message": "Unified smart cycle triggered in background."}
 
 @app.get("/status")
 async def get_status():
-    sentry_status = trade_manager_global.watchlist if trade_manager_global else {}
+    """جلب حالة النظام التفصيلية"""
     return {
-        "initialized": state_manager.initialization_complete,
-        "sentry_targets": list(sentry_status.keys()),
-        # استخدام الاسم الجديد في الحالة
-        "hybrid_threshold": data_manager_global.HYBRID_ENTRY_THRESHOLD if data_manager_global else None
+        "initialized": sys_state.ready,
+        "cycle_running": sys_state.cycle_running,
+        "open_positions_count": len(trade_manager.open_positions) if trade_manager else 0,
+        "open_positions": list(trade_manager.open_positions.keys()) if trade_manager else [],
+        "watchlist_count": len(trade_manager.watchlist) if trade_manager else 0,
+        "watchlist": list(trade_manager.watchlist.keys()) if trade_manager else []
     }
 
 if __name__ == "__main__":
+    import uvicorn
+    # تشغيل السيرفر
     uvicorn.run(app, host="0.0.0.0", port=7860)