Update ML.py

ML.py

@@ -491,49 +491,77 @@ class MLProcessor:
     
     async def process_and_score_symbol_enhanced(self, raw_data):
         try:
-            if not raw_data or not raw_data.get('ohlcv'): return None
+            if not raw_data or not raw_data.get('ohlcv'): 
+                print(f"❌ بيانات غير صالحة للرمز {raw_data.get('symbol', 'unknown')}")
+                return None
+            
+            symbol = raw_data['symbol']
+            print(f"🔍 معالجة الرمز {symbol}...")
+            
             raw_data['raw_ohlcv'] = raw_data.get('ohlcv', {})
             base_analysis = await self.process_and_score_symbol(raw_data)
-            if not base_analysis: return None
+            if not base_analysis: 
+                print(f"❌ فشل التحليل الأساسي للرمز {symbol}")
+                return None
+            
             try:
                 current_price = base_analysis.get('current_price', 0)
                 quality_issues = self._validate_indicators_quality_enhanced(base_analysis.get('advanced_indicators', {}), current_price)
+                
                 if quality_issues:
-                    for issue in quality_issues: print(f"   {issue}")
+                    print(f"⚠️ مشاكل جودة في {symbol}:")
+                    for issue in quality_issues: 
+                        print(f"   {issue}")
+                
                 if hasattr(self, 'strategy_engine') and self.strategy_engine:
                     strategy_scores, base_scores = await self.strategy_engine.evaluate_all_strategies(base_analysis, self.market_context)
                     base_analysis['strategy_scores'] = strategy_scores
                     base_analysis['base_strategy_scores'] = base_scores
+                    
                     if base_scores:
                         best_strategy = max(base_scores.items(), key=lambda x: x[1])
                         best_strategy_name = best_strategy[0]
                         best_strategy_score = best_strategy[1]
                         base_analysis['recommended_strategy'] = best_strategy_name
                         base_analysis['strategy_confidence'] = best_strategy_score
-                        if best_strategy_score > 0.3: base_analysis['target_strategy'] = best_strategy_name
-                        else: base_analysis['target_strategy'] = 'GENERIC'
+                        
+                        if best_strategy_score > 0.3: 
+                            base_analysis['target_strategy'] = best_strategy_name
+                        else: 
+                            base_analysis['target_strategy'] = 'GENERIC'
+                            
+                        print(f"🎯 أفضل استراتيجية لـ {symbol}: {best_strategy_name} (ثقة: {best_strategy_score:.2f})")
                     else:
                         base_analysis['recommended_strategy'] = 'GENERIC'
                         base_analysis['strategy_confidence'] = 0.3
                         base_analysis['target_strategy'] = 'GENERIC'
+                        print(f"⚠️ لا توجد استراتيجيات مناسبة لـ {symbol}")
+                    
                     enhanced_score = self._calculate_enhanced_score_with_safety(base_analysis, strategy_scores, quality_issues)
                     base_analysis['enhanced_final_score'] = enhanced_score
+                    print(f"📊 النتيجة النهائية لـ {symbol}: {enhanced_score:.3f}")
                 else:
                     base_analysis['strategy_scores'] = {}
                     base_analysis['enhanced_final_score'] = base_analysis.get('final_score', 0.5)
                     base_analysis['recommended_strategy'] = 'GENERIC'
                     base_analysis['strategy_confidence'] = 0.3
                     base_analysis['target_strategy'] = 'GENERIC'
+                    print(f"⚠️ محرك الاستراتيجيات غير متوفر لـ {symbol}")
+                
                 base_analysis['quality_warnings'] = quality_issues
+                
             except Exception as strategy_error:
+                print(f"❌ خطأ في تقييم الاستراتيجية لـ {symbol}: {strategy_error}")
                 base_analysis['strategy_scores'] = {}
                 base_analysis['enhanced_final_score'] = base_analysis.get('final_score', 0.5)
                 base_analysis['recommended_strategy'] = 'GENERIC'
                 base_analysis['strategy_confidence'] = 0.3
                 base_analysis['target_strategy'] = 'GENERIC'
                 base_analysis['quality_warnings'] = ['Strategy evaluation failed']
+            
             return base_analysis
         except Exception as error:
+            print(f"❌ خطأ في المعالجة المحسنة للرمز {raw_data.get('symbol', 'unknown')}: {error}")
             return await self.process_and_score_symbol(raw_data)
 
     def _improve_fibonacci_levels(self, daily_dataframe, current_price):
@@ -555,17 +583,27 @@ class MLProcessor:
         symbol = raw_data['symbol']
         ohlcv_data = raw_data['ohlcv']
         reasons_for_candidacy = raw_data.get('reasons', [])
-        if not ohlcv_data: return None
+        
+        if not ohlcv_data: 
+            print(f"❌ لا توجد بيانات OHLCV للرمز {symbol}")
+            return None
+        
         try:
+            print(f"📈 تحليل المؤشرات للرمز {symbol}...")
             all_indicators = {}
             for timeframe, candles in ohlcv_data.items():
                 if candles:
                     dataframe = pd.DataFrame(candles, columns=['time', 'open', 'high', 'low', 'close', 'volume'])
                     dataframe[['open', 'high', 'low', 'close', 'volume']] = dataframe[['open', 'high', 'low', 'close', 'volume']].astype(float)
                     all_indicators[timeframe] = self._calculate_indicators(dataframe, timeframe)
+            
             hourly_dataframe = pd.DataFrame(ohlcv_data.get('1h', []), columns=['time', 'open', 'high', 'low', 'close', 'volume'])
-            if hourly_dataframe.empty: return None
+            if hourly_dataframe.empty: 
+                print(f"❌ لا توجد بيانات ساعة للرمز {symbol}")
+                return None
+            
             hourly_dataframe[['open', 'high', 'low', 'close', 'volume']] = hourly_dataframe[['open', 'high', 'low', 'close', 'volume']].astype(float)
+            
             try:
                 current_price = float(hourly_dataframe['close'].iloc[-1])
                 if ohlcv_data.get('5m'):
@@ -573,21 +611,37 @@ class MLProcessor:
                     if not five_minute_dataframe.empty:
                         five_minute_dataframe[['open', 'high', 'low', 'close', 'volume']] = five_minute_dataframe[['open', 'high', 'low', 'close', 'volume']].astype(float)
                         current_price = float(five_minute_dataframe['close'].iloc[-1])
+                
                 liquidity_score = self._calculate_liquidity_score(hourly_dataframe)
                 daily_dataframe = pd.DataFrame(ohlcv_data.get('1d', []), columns=['time', 'open', 'high', 'low', 'close', 'volume'])
-                if not daily_dataframe.empty: daily_dataframe[['open', 'high', 'low', 'close', 'volume']] = daily_dataframe[['open', 'high', 'low', 'close', 'volume']].astype(float)
+                if not daily_dataframe.empty: 
+                    daily_dataframe[['open', 'high', 'low', 'close', 'volume']] = daily_dataframe[['open', 'high', 'low', 'close', 'volume']].astype(float)
+                
                 average_daily_volume = float(daily_dataframe['volume'].mean()) if not daily_dataframe.empty else 0.0
                 fibonacci_levels = self._improve_fibonacci_levels(daily_dataframe, current_price)
-                try: whale_data = await self.data_manager.get_symbol_specific_whale_data(symbol)
+                
+                try: 
+                    whale_data = await self.data_manager.get_symbol_specific_whale_data(symbol)
+                    print(f"🐋 بيانات الحيتان لـ {symbol}: {whale_data.get('transfer_count', 0)} تحويل")
                 except Exception as whale_error:
                     whale_data = {"transfer_count": 0, "total_volume": 0, "source": "no_data", "data_available": False}
+                    print(f"⚠️ لا توجد بيانات حيتان لـ {symbol}")
+                
                 whale_score = await self.data_manager.whale_monitor._calculate_whale_activity_score(whale_data)
                 opportunity_classification = self.classify_opportunity_type(all_indicators, current_price)
                 initial_score = self._calculate_initial_score(all_indicators, current_price, self.market_context)
+                
+                print(f"🎲 تشغيل محاكاة مونت كارلو لـ {symbol}...")
                 monte_carlo_probability = self._run_monte_carlo_simulation(hourly_dataframe)
+                print(f"📊 نتيجة مونت كارلو لـ {symbol}: {monte_carlo_probability:.3f}")
+                
                 final_score = (0.35 * initial_score) + (0.50 * monte_carlo_probability) + (0.15 * whale_score)
                 final_score *= opportunity_classification['confidence']
+                
                 normalized_indicators = {timeframe: self._normalize_features_corrected(indicators) for timeframe, indicators in all_indicators.items()}
+                
+                print(f"✅ اكتمل تحليل {symbol} - النتيجة: {final_score:.3f}")
+                
                 return {
                     'symbol': symbol, 'reasons_for_candidacy': reasons_for_candidacy, 'current_price': float(current_price), 
                     'liquidity_score': float(liquidity_score) if not np.isnan(liquidity_score) else 0.0, 'avg_daily_volume': float(average_daily_volume),
@@ -598,8 +652,11 @@ class MLProcessor:
                     'recommended_strategy': 'GENERIC', 'enhanced_final_score': float(final_score), 'target_strategy': 'GENERIC',
                     'raw_ohlcv': ohlcv_data
                 }
-            except (KeyError, IndexError) as error: return None
+            except (KeyError, IndexError) as error: 
+                print(f"❌ خطأ في فهارس البيانات لـ {symbol}: {error}")
+                return None
         except Exception as error: 
+            print(f"❌ خطأ عام في معالجة الرمز {symbol}: {error}")
             return None
 
     def _calculate_indicators(self, dataframe, timeframe):
@@ -659,19 +716,27 @@ class MLProcessor:
         return normalized_features
 
     def _run_monte_carlo_simulation(self, dataframe, number_of_simulations=1000, number_of_steps=20):
-        if dataframe.empty or len(dataframe) < 2: return 0.0
+        if dataframe.empty or len(dataframe) < 2: 
+            return 0.0
+        
         log_returns = np.log(dataframe['close'] / dataframe['close'].shift(1)).dropna()
-        if log_returns.empty: return 0.0
+        if log_returns.empty: 
+            return 0.0
+        
         mean_return = log_returns.mean()
         volatility = log_returns.std()
         initial_price = dataframe['close'].iloc[-1]
         success_count = 0
+        
         for _ in range(number_of_simulations):
             random_values = np.random.normal(0, 1, number_of_steps)
             daily_returns = np.exp(mean_return - 0.5 * volatility**2 + volatility * random_values)
             simulated_prices = initial_price * daily_returns.cumprod()
-            if (simulated_prices[-1] / initial_price) > 1.02: success_count += 1
-        return success_count / number_of_simulations
+            if (simulated_prices[-1] / initial_price) > 1.02: 
+                success_count += 1
+        
+        probability = success_count / number_of_simulations
+        return probability
 
     def _calculate_initial_score(self, indicators, current_price, market_context):
         score = 0.5
@@ -758,4 +823,18 @@ class MLProcessor:
     
     def filter_top_candidates(self, candidates, number_of_candidates=10):
         valid_candidates = [candidate for candidate in candidates if candidate is not None]
-        return sorted(valid_candidates, key=lambda candidate: candidate.get('enhanced_final_score', candidate.get('final_score', 0)), reverse=True)[:number_of_candidates]
+        
+        if not valid_candidates:
+            print("❌ لا توجد مرشحات صالحة للتصفية")
+            return []
+        
+        sorted_candidates = sorted(valid_candidates, key=lambda candidate: candidate.get('enhanced_final_score', candidate.get('final_score', 0)), reverse=True)
+        top_candidates = sorted_candidates[:number_of_candidates]
+        
+        print(f"🎖️ أفضل {len(top_candidates)} مرشح:")
+        for i, candidate in enumerate(top_candidates):
+            score = candidate.get('enhanced_final_score', 0)
+            strategy = candidate.get('recommended_strategy', 'GENERIC')
+            print(f"   {i+1}. {candidate['symbol']}: {score:.3f} - {strategy}")
+        
+        return top_candidates