Update app.py

app.py

@@ -25,45 +25,71 @@ learning_engine_global = None
 trade_manager_global = None
 sentiment_analyzer_global = None
 
+class StateManager:
+    def __init__(self):
+        self.market_analysis_lock = asyncio.Lock()
+        self.trade_analysis_lock = asyncio.Lock()
+        self.initialization_complete = False
+        self.services_initialized = {
+            'r2_service': False,
+            'data_manager': False,
+            'llm_service': False,
+            'learning_engine': False,
+            'trade_manager': False,
+            'sentiment_analyzer': False
+        }
+
+    async def wait_for_initialization(self, timeout=30):
+        start_time = time.time()
+        while not self.initialization_complete and (time.time() - start_time) < timeout:
+            await asyncio.sleep(1)
+        return self.initialization_complete
+
+    def set_service_initialized(self, service_name):
+        self.services_initialized[service_name] = True
+        if all(self.services_initialized.values()):
+            self.initialization_complete = True
+
+state_manager = StateManager()
+
 async def monitor_market_async():
     global data_manager_global, sentiment_analyzer_global
-    init_attempts = 0
-    while data_manager_global is None and init_attempts < 10: 
-        await asyncio.sleep(3)
-        init_attempts += 1
-    if data_manager_global is None: 
+    
+    if not await state_manager.wait_for_initialization():
+        print("❌ فشل تهيئة الخدمات - إيقاف مراقبة السوق")
         return
         
     while True:
         try:
-            market_context = await sentiment_analyzer_global.get_market_sentiment()
-            if not market_context: 
-                state.MARKET_STATE_OK = True
-                await asyncio.sleep(60)
-                continue
-                
-            whale_analysis = market_context.get('general_whale_activity', {})
-            is_critical = whale_analysis.get('critical_alert', False)
-            bitcoin_sentiment = market_context.get('btc_sentiment')
-            fear_greed_index = market_context.get('fear_and_greed_index')
-            
-            should_halt_trading, halt_reason = False, ""
-            if is_critical: 
-                should_halt_trading, halt_reason = True, "نشاط حيتان حرج"
-            elif bitcoin_sentiment == 'BEARISH' and (fear_greed_index is not None and fear_greed_index < 30): 
-                should_halt_trading, halt_reason = True, "ظروف سوق هابطة"
-                
-            if should_halt_trading:
-                state.MARKET_STATE_OK = False
-                await r2_service_global.save_system_logs_async({"market_halt": True, "reason": halt_reason})
-            else:
-                if not state.MARKET_STATE_OK: 
-                    print("تحسنت ظروف السوق. استئناف العمليات العادية.")
-                state.MARKET_STATE_OK = True
+            async with state_manager.market_analysis_lock:
+                market_context = await sentiment_analyzer_global.get_market_sentiment()
+                if not market_context: 
+                    state.MARKET_STATE_OK = True
+                    await asyncio.sleep(60)
+                    continue
+                    
+                whale_analysis = market_context.get('general_whale_activity', {})
+                is_critical = whale_analysis.get('critical_alert', False)
+                bitcoin_sentiment = market_context.get('btc_sentiment')
+                fear_greed_index = market_context.get('fear_and_greed_index')
                 
+                should_halt_trading, halt_reason = False, ""
+                if is_critical: 
+                    should_halt_trading, halt_reason = True, "نشاط حيتان حرج"
+                elif bitcoin_sentiment == 'BEARISH' and (fear_greed_index is not None and fear_greed_index < 30): 
+                    should_halt_trading, halt_reason = True, "ظروف سوق هابطة"
+                    
+                if should_halt_trading:
+                    state.MARKET_STATE_OK = False
+                    await r2_service_global.save_system_logs_async({"market_halt": True, "reason": halt_reason})
+                else:
+                    if not state.MARKET_STATE_OK: 
+                        print("✅ تحسنت ظروف السوق. استئناف العمليات العادية.")
+                    state.MARKET_STATE_OK = True
+                    
             await asyncio.sleep(60)
         except Exception as error:
-            print(f"خطأ أثناء مراقبة السوق: {error}")
+            print(f"❌ خطأ أثناء مراقبة السوق: {error}")
             state.MARKET_STATE_OK = True
             await asyncio.sleep(60)
 
@@ -89,13 +115,13 @@ async def analyze_market_strategy(market_context):
                 fallback_strategy = "GENERIC"
             strategy_data = {
                 "primary_strategy": fallback_strategy,
-                "reasoning": "Fallback strategy",
+                "reasoning": "Fallback strategy due to analysis error",
                 "risk_tolerance": 5,
                 "optimal_scan_count": 100
             }
         return strategy_data
     except Exception as error:
-        print(f"فشل تحليل استراتيجية السوق: {error}")
+        print(f"❌ فشل تحليل استراتيجية السوق: {error}")
         return {
             "primary_strategy": "GENERIC",
             "reasoning": "Fallback due to analysis error",
@@ -125,7 +151,7 @@ async def find_strategy_specific_candidates(strategy, scan_count):
                     if processed: 
                         processed_candidates.append(processed)
             except Exception as e: 
-                print(f"Failed to process {candidate.get('symbol')}: {e}")
+                print(f"❌ Failed to process {candidate.get('symbol')}: {e}")
                 
         if not processed_candidates: 
             return []
@@ -146,7 +172,7 @@ async def find_strategy_specific_candidates(strategy, scan_count):
             
         return top_candidates
     except Exception as error:
-        print(f"Advanced filtering failed: {error}")
+        print(f"❌ Advanced filtering failed: {error}")
         return []
 
 async def find_new_opportunities_async():
@@ -242,11 +268,11 @@ async def find_new_opportunities_async():
                         "strategy": final_strategy
                     }
             except Exception as error: 
-                print(f"LLM error for {candidate.get('symbol', 'unknown')}: {error}")
+                print(f"❌ LLM error for {candidate.get('symbol', 'unknown')}: {error}")
                 
         return None
     except Exception as error:
-        print(f"Error while scanning for opportunities: {error}")
+        print(f"❌ Error while scanning for opportunities: {error}")
         await r2_service_global.save_system_logs_async({
             "opportunity_scan_error": True, 
             "error": str(error)
@@ -256,70 +282,71 @@ async def find_new_opportunities_async():
 async def re_analyze_open_trade_async(trade_data):
     symbol = trade_data.get('symbol')
     try:
-        entry_time = datetime.fromisoformat(trade_data['entry_timestamp'])
-        current_time = datetime.now()
-        hold_minutes = (current_time - entry_time).total_seconds() / 60
-        
-        original_strategy = trade_data.get('strategy')
-        if not original_strategy or original_strategy == 'unknown': 
-            original_strategy = trade_data.get('decision_data', {}).get('strategy', 'GENERIC')
-            
-        try: 
-            market_context = await data_manager_global.get_market_context_async()
-        except Exception: 
-            market_context = {'btc_sentiment': 'NEUTRAL'}
-            
-        symbol_with_reasons = [{'symbol': symbol, 'reasons': ['re-analysis']}]
-        ohlcv_data_list = await data_manager_global.get_fast_pass_data_async(symbol_with_reasons)
-        if not ohlcv_data_list: 
-            return None
+        async with state_manager.trade_analysis_lock:
+            entry_time = datetime.fromisoformat(trade_data['entry_timestamp'])
+            current_time = datetime.now()
+            hold_minutes = (current_time - entry_time).total_seconds() / 60
             
-        raw_data = ohlcv_data_list[0]
-        try:
-            updated_market_context = await data_manager_global.get_market_context_async()
-            if updated_market_context: 
-                market_context = updated_market_context
-        except Exception: 
-            pass
+            original_strategy = trade_data.get('strategy')
+            if not original_strategy or original_strategy == 'unknown': 
+                original_strategy = trade_data.get('decision_data', {}).get('strategy', 'GENERIC')
+                
+            try: 
+                market_context = await data_manager_global.get_market_context_async()
+            except Exception: 
+                market_context = {'btc_sentiment': 'NEUTRAL'}
+                
+            symbol_with_reasons = [{'symbol': symbol, 'reasons': ['re-analysis']}]
+            ohlcv_data_list = await data_manager_global.get_fast_pass_data_async(symbol_with_reasons)
+            if not ohlcv_data_list: 
+                return None
+                
+            raw_data = ohlcv_data_list[0]
+            try:
+                updated_market_context = await data_manager_global.get_market_context_async()
+                if updated_market_context: 
+                    market_context = updated_market_context
+            except Exception: 
+                pass
+                
+            feature_processor = FeatureProcessor(market_context, data_manager_global, learning_engine_global)
+            processed_data = await feature_processor.process_and_score_symbol(raw_data)
+            if not processed_data: 
+                return None
+                
+            await r2_service_global.save_candidates_data_async(
+                candidates_data=None, 
+                reanalysis_data={
+                    'market_context': market_context, 
+                    'processed_data': processed_data
+                }
+            )
             
-        feature_processor = FeatureProcessor(market_context, data_manager_global, learning_engine_global)
-        processed_data = await feature_processor.process_and_score_symbol(raw_data)
-        if not processed_data: 
-            return None
+            try: 
+                re_analysis_decision = await llm_service_global.re_analyze_trade_async(trade_data, processed_data)
+            except Exception: 
+                re_analysis_decision = local_re_analyze_trade(trade_data, processed_data)
+                
+            final_decision = _apply_patience_logic(re_analysis_decision, hold_minutes, trade_data, processed_data)
+            if not final_decision.get('strategy'): 
+                final_decision['strategy'] = original_strategy
+                
+            await r2_service_global.save_system_logs_async({
+                "trade_reanalyzed": True, 
+                "symbol": symbol, 
+                "action": final_decision.get('action'),
+                "hold_minutes": hold_minutes, 
+                "strategy": final_decision.get('strategy')
+            })
             
-        await r2_service_global.save_candidates_data_async(
-            candidates_data=None, 
-            reanalysis_data={
-                'market_context': market_context, 
-                'processed_data': processed_data
+            return {
+                "symbol": symbol, 
+                "decision": final_decision,
+                "current_price": processed_data.get('current_price'), 
+                "hold_minutes": hold_minutes
             }
-        )
-        
-        try: 
-            re_analysis_decision = await llm_service_global.re_analyze_trade_async(trade_data, processed_data)
-        except Exception: 
-            re_analysis_decision = local_re_analyze_trade(trade_data, processed_data)
-            
-        final_decision = _apply_patience_logic(re_analysis_decision, hold_minutes, trade_data, processed_data)
-        if not final_decision.get('strategy'): 
-            final_decision['strategy'] = original_strategy
-            
-        await r2_service_global.save_system_logs_async({
-            "trade_reanalyzed": True, 
-            "symbol": symbol, 
-            "action": final_decision.get('action'),
-            "hold_minutes": hold_minutes, 
-            "strategy": final_decision.get('strategy')
-        })
-        
-        return {
-            "symbol": symbol, 
-            "decision": final_decision,
-            "current_price": processed_data.get('current_price'), 
-            "hold_minutes": hold_minutes
-        }
     except Exception as error:
-        print(f"Error during trade re-analysis: {error}")
+        print(f"❌ Error during trade re-analysis: {error}")
         await r2_service_global.save_system_logs_async({
             "reanalysis_error": True, 
             "symbol": symbol, 
@@ -329,6 +356,10 @@ async def re_analyze_open_trade_async(trade_data):
 
 async def run_bot_cycle_async():
     try:
+        if not await state_manager.wait_for_initialization():
+            print("❌ الخدمات غير مهيأة بالكامل - تخطي الدورة")
+            return
+
         await r2_service_global.save_system_logs_async({"cycle_started": True})
         if not r2_service_global.acquire_lock(): 
             return
@@ -392,7 +423,7 @@ async def run_bot_cycle_async():
                 "open_trades": len(open_trades)
             })
     except Exception as error:
-        print(f"Unhandled error in main cycle: {error}")
+        print(f"❌ Unhandled error in main cycle: {error}")
         await r2_service_global.save_system_logs_async({
             "cycle_error": True, 
             "error": str(error)
@@ -403,32 +434,63 @@ async def run_bot_cycle_async():
 @asynccontextmanager
 async def lifespan(application: FastAPI):
     global r2_service_global, data_manager_global, llm_service_global, learning_engine_global, trade_manager_global, sentiment_analyzer_global
+    
+    initialization_successful = False
     try:
+        print("🚀 بدء تهيئة التطبيق...")
+        
+        # 1. تهيئة R2 أولاً
         r2_service_global = R2Service()
-        llm_service_global = LLMService()
+        state_manager.set_service_initialized('r2_service')
+        print("✅ R2 Service initialized")
+
+        # 2. تحميل قاعدة البيانات
         contracts_database = await r2_service_global.load_contracts_db_async()
-        
+        print("✅ Contracts database loaded")
+
+        # 3. تهيئة Whale Monitor أولاً
         from whale_news_data import EnhancedWhaleMonitor
         whale_monitor_global = EnhancedWhaleMonitor(contracts_database)
-        whale_monitor_global.data_manager = data_manager_global
-        
+        print("✅ Whale Monitor initialized")
+
+        # 4. تهيئة Data Manager
         data_manager_global = DataManager(contracts_database, whale_monitor_global)
         await data_manager_global.initialize()
-        
+        whale_monitor_global.data_manager = data_manager_global
+        state_manager.set_service_initialized('data_manager')
+        print("✅ Data Manager initialized")
+
+        # 5. تهيئة الخدمات الأخرى
+        llm_service_global = LLMService()
+        state_manager.set_service_initialized('llm_service')
+        print("✅ LLM Service initialized")
+
         sentiment_analyzer_global = SentimentAnalyzer(data_manager_global)
+        state_manager.set_service_initialized('sentiment_analyzer')
+        print("✅ Sentiment Analyzer initialized")
+
         learning_engine_global = LearningEngine(r2_service_global, data_manager_global)
         await learning_engine_global.initialize_enhanced()
         await learning_engine_global.force_strategy_learning()
+        state_manager.set_service_initialized('learning_engine')
+        print("✅ Learning Engine initialized")
+
         trade_manager_global = TradeManager(r2_service_global, learning_engine_global, data_manager_global)
-        
-        whale_monitor_global.data_manager = data_manager_global
-        
+        state_manager.set_service_initialized('trade_manager')
+        print("✅ Trade Manager initialized")
+
+        # 6. بدء الخدمات الخلفية
         asyncio.create_task(monitor_market_async())
         asyncio.create_task(trade_manager_global.start_trade_monitoring())
+        
         await r2_service_global.save_system_logs_async({"application_started": True})
+        initialization_successful = True
+        print("🎯 التطبيق جاهز للعمل")
+        
         yield
+        
     except Exception as error:
-        print(f"Application startup failed: {error}")
+        print(f"❌ Application startup failed: {error}")
         if r2_service_global: 
             await r2_service_global.save_system_logs_async({
                 "application_startup_failed": True, 
@@ -442,6 +504,8 @@ application = FastAPI(lifespan=lifespan)
 
 @application.get("/run-cycle")
 async def run_cycle_api():
+    if not state_manager.initialization_complete:
+        raise HTTPException(status_code=503, detail="الخدمات غير مهيأة بالكامل")
     asyncio.create_task(run_bot_cycle_async())
     return {"message": "Bot cycle initiated"}
 
@@ -456,7 +520,9 @@ async def health_check():
         api_stats = data_manager_global.get_performance_stats()
         
     return {
-        "status": "healthy", 
+        "status": "healthy" if state_manager.initialization_complete else "initializing",
+        "initialization_complete": state_manager.initialization_complete,
+        "services_initialized": state_manager.services_initialized,
         "timestamp": datetime.now().isoformat(), 
         "services": {
             "r2_service": "initialized" if r2_service_global else "uninitialized",
@@ -472,6 +538,9 @@ async def health_check():
 @application.get("/stats")
 async def get_performance_stats():
     try:
+        if not state_manager.initialization_complete:
+            raise HTTPException(status_code=503, detail="الخدمات غير مهيأة بالكامل")
+
         market_context = await data_manager_global.get_market_context_async() if data_manager_global else {}
         learning_stats = {}
         if learning_engine_global and learning_engine_global.initialized: 
@@ -515,28 +584,34 @@ async def get_logs_status():
 
 async def cleanup_on_shutdown():
     global r2_service_global, data_manager_global, trade_manager_global, learning_engine_global
-    print("Shutdown signal received. Cleaning up...")
-    if r2_service_global:
-        try: 
-            await r2_service_global.save_system_logs_async({"application_shutdown": True})
-        except Exception: 
-            pass
-            
+    print("🛑 Shutdown signal received. Cleaning up...")
+    
+    if trade_manager_global: 
+        trade_manager_global.stop_monitoring()
+        print("✅ Trade monitoring stopped")
+        
     if learning_engine_global and learning_engine_global.initialized:
         try:
             await learning_engine_global.save_weights_to_r2()
             await learning_engine_global.save_performance_history()
-        except Exception: 
-            pass
+            print("✅ Learning engine data saved")
+        except Exception as e: 
+            print(f"❌ Failed to save learning engine data: {e}")
             
-    if trade_manager_global: 
-        trade_manager_global.stop_monitoring()
-        
-    if r2_service_global and r2_service_global.lock_acquired: 
-        r2_service_global.release_lock()
-        
     if data_manager_global: 
         await data_manager_global.close()
+        print("✅ Data manager closed")
+        
+    if r2_service_global:
+        try: 
+            await r2_service_global.save_system_logs_async({"application_shutdown": True})
+            print("✅ Shutdown log saved")
+        except Exception as e: 
+            print(f"❌ Failed to save shutdown log: {e}")
+            
+        if r2_service_global.lock_acquired: 
+            r2_service_global.release_lock()
+            print("✅ R2 lock released")
 
 def signal_handler(signum, frame):
     asyncio.create_task(cleanup_on_shutdown())