Update ML.py

ML.py

@@ -1,4 +1,3 @@
-# ML.py - الإصدار المحدث مع إصلاح الأخطاء الحرجة
 import pandas as pd
 import pandas_ta as ta
 import numpy as np
@@ -17,8 +16,7 @@ class AdvancedTechnicalAnalyzer:
         }
     
     def calculate_all_indicators(self, dataframe, timeframe):
-        if dataframe.empty: 
-            return {}
+        if dataframe.empty: return {}
         indicators = {}
         indicators.update(self._calculate_trend_indicators(dataframe))
         indicators.update(self._calculate_momentum_indicators(dataframe))
@@ -29,66 +27,56 @@ class AdvancedTechnicalAnalyzer:
     
     def _calculate_trend_indicators(self, dataframe):
         trend = {}
-        trend['ema_9'] = float(ta.ema(dataframe['close'], length=9).iloc[-1]) if len(dataframe) >= 9 else None
-        trend['ema_21'] = float(ta.ema(dataframe['close'], length=21).iloc[-1]) if len(dataframe) >= 21 else None
-        trend['ema_50'] = float(ta.ema(dataframe['close'], length=50).iloc[-1]) if len(dataframe) >= 50 else None
-        trend['ema_200'] = float(ta.ema(dataframe['close'], length=200).iloc[-1]) if len(dataframe) >= 200 else None
-        
+        if len(dataframe) >= 9: trend['ema_9'] = float(ta.ema(dataframe['close'], length=9).iloc[-1])
+        if len(dataframe) >= 21: trend['ema_21'] = float(ta.ema(dataframe['close'], length=21).iloc[-1])
+        if len(dataframe) >= 50: trend['ema_50'] = float(ta.ema(dataframe['close'], length=50).iloc[-1])
+        if len(dataframe) >= 200: trend['ema_200'] = float(ta.ema(dataframe['close'], length=200).iloc[-1])
         if len(dataframe) >= 26:
             ichimoku = ta.ichimoku(dataframe['high'], dataframe['low'], dataframe['close'])
             if ichimoku is not None:
-                trend['ichimoku_conversion'] = float(ichimoku[0]['ITS_9'].iloc[-1]) if not ichimoku[0]['ITS_9'].empty else None
-                trend['ichimoku_base'] = float(ichimoku[0]['IKS_26'].iloc[-1]) if not ichimoku[0]['IKS_26'].empty else None
-                trend['ichimoku_span_a'] = float(ichimoku[0]['ISA_9'].iloc[-1]) if not ichimoku[0]['ISA_9'].empty else None
-                trend['ichimoku_span_b'] = float(ichimoku[0]['ISB_26'].iloc[-1]) if not ichimoku[0]['ISB_26'].empty else None
-        
+                if not ichimoku[0]['ITS_9'].empty: trend['ichimoku_conversion'] = float(ichimoku[0]['ITS_9'].iloc[-1])
+                if not ichimoku[0]['IKS_26'].empty: trend['ichimoku_base'] = float(ichimoku[0]['IKS_26'].iloc[-1])
+                if not ichimoku[0]['ISA_9'].empty: trend['ichimoku_span_a'] = float(ichimoku[0]['ISA_9'].iloc[-1])
+                if not ichimoku[0]['ISB_26'].empty: trend['ichimoku_span_b'] = float(ichimoku[0]['ISB_26'].iloc[-1])
         if len(dataframe) >= 14:
             adx_result = ta.adx(dataframe['high'], dataframe['low'], dataframe['close'], length=14)
             if adx_result is not None:
-                trend['adx'] = float(adx_result['ADX_14'].iloc[-1]) if not adx_result['ADX_14'].empty else None
-                trend['dmi_plus'] = float(adx_result['DMP_14'].iloc[-1]) if not adx_result['DMP_14'].empty else None
-                trend['dmi_minus'] = float(adx_result['DMN_14'].iloc[-1]) if not adx_result['DMN_14'].empty else None
-        
+                if not adx_result['ADX_14'].empty: trend['adx'] = float(adx_result['ADX_14'].iloc[-1])
+                if not adx_result['DMP_14'].empty: trend['dmi_plus'] = float(adx_result['DMP_14'].iloc[-1])
+                if not adx_result['DMN_14'].empty: trend['dmi_minus'] = float(adx_result['DMN_14'].iloc[-1])
         if len(dataframe) >= 5:
             psar = ta.psar(dataframe['high'], dataframe['low'], dataframe['close'])
-            if psar is not None:
-                trend['psar'] = float(psar['PSARl_0.02_0.2'].iloc[-1]) if not psar['PSARl_0.02_0.2'].empty else None
+            if psar is not None and not psar['PSARl_0.02_0.2'].empty: trend['psar'] = float(psar['PSARl_0.02_0.2'].iloc[-1])
         return {key: value for key, value in trend.items() if value is not None}
     
     def _calculate_momentum_indicators(self, dataframe):
         momentum = {}
         if len(dataframe) >= 14:
             rsi = ta.rsi(dataframe['close'], length=14)
-            momentum['rsi'] = float(rsi.iloc[-1]) if not rsi.empty else None
-        
+            if not rsi.empty: momentum['rsi'] = float(rsi.iloc[-1])
         if len(dataframe) >= 14:
             stoch_rsi = ta.stochrsi(dataframe['close'], length=14)
             if stoch_rsi is not None:
-                momentum['stoch_rsi_k'] = float(stoch_rsi['STOCHRSIk_14_14_3_3'].iloc[-1]) if not stoch_rsi['STOCHRSIk_14_14_3_3'].empty else None
-                momentum['stoch_rsi_d'] = float(stoch_rsi['STOCHRSId_14_14_3_3'].iloc[-1]) if not stoch_rsi['STOCHRSId_14_14_3_3'].empty else None
-        
+                if not stoch_rsi['STOCHRSIk_14_14_3_3'].empty: momentum['stoch_rsi_k'] = float(stoch_rsi['STOCHRSIk_14_14_3_3'].iloc[-1])
+                if not stoch_rsi['STOCHRSId_14_14_3_3'].empty: momentum['stoch_rsi_d'] = float(stoch_rsi['STOCHRSId_14_14_3_3'].iloc[-1])
         if len(dataframe) >= 26:
             macd = ta.macd(dataframe['close'])
             if macd is not None:
-                momentum['macd_line'] = float(macd['MACD_12_26_9'].iloc[-1]) if not macd['MACD_12_26_9'].empty else None
-                momentum['macd_signal'] = float(macd['MACDs_12_26_9'].iloc[-1]) if not macd['MACDs_12_26_9'].empty else None
-                momentum['macd_hist'] = float(macd['MACDh_12_26_9'].iloc[-1]) if not macd['MACDh_12_26_9'].empty else None
-        
+                if not macd['MACD_12_26_9'].empty: momentum['macd_line'] = float(macd['MACD_12_26_9'].iloc[-1])
+                if not macd['MACDs_12_26_9'].empty: momentum['macd_signal'] = float(macd['MACDs_12_26_9'].iloc[-1])
+                if not macd['MACDh_12_26_9'].empty: momentum['macd_hist'] = float(macd['MACDh_12_26_9'].iloc[-1])
         if len(dataframe) >= 14:
             williams = ta.willr(dataframe['high'], dataframe['low'], dataframe['close'], length=14)
-            momentum['williams_r'] = float(williams.iloc[-1]) if not williams.empty else None
-        
+            if not williams.empty: momentum['williams_r'] = float(williams.iloc[-1])
         if len(dataframe) >= 20:
             cci = ta.cci(dataframe['high'], dataframe['low'], dataframe['close'], length=20)
-            momentum['cci'] = float(cci.iloc[-1]) if not cci.empty else None
-        
+            if not cci.empty: momentum['cci'] = float(cci.iloc[-1])
         if len(dataframe) >= 34:
             awesome_oscillator = ta.ao(dataframe['high'], dataframe['low'])
-            momentum['awesome_oscillator'] = float(awesome_oscillator.iloc[-1]) if not awesome_oscillator.empty else None
-        
+            if not awesome_oscillator.empty: momentum['awesome_oscillator'] = float(awesome_oscillator.iloc[-1])
         if len(dataframe) >= 10:
             momentum_indicator = ta.mom(dataframe['close'], length=10)
-            momentum['momentum'] = float(momentum_indicator.iloc[-1]) if not momentum_indicator.empty else None
+            if not momentum_indicator.empty: momentum['momentum'] = float(momentum_indicator.iloc[-1])
         return {key: value for key, value in momentum.items() if value is not None}
     
     def _calculate_volatility_indicators(self, dataframe):
@@ -96,185 +84,125 @@ class AdvancedTechnicalAnalyzer:
         if len(dataframe) >= 20:
             bollinger_bands = ta.bbands(dataframe['close'], length=20, std=2)
             if bollinger_bands is not None:
-                volatility['bb_upper'] = float(bollinger_bands['BBU_20_2.0'].iloc[-1]) if not bollinger_bands['BBU_20_2.0'].empty else None
-                volatility['bb_middle'] = float(bollinger_bands['BBM_20_2.0'].iloc[-1]) if not bollinger_bands['BBM_20_2.0'].empty else None
-                volatility['bb_lower'] = float(bollinger_bands['BBL_20_2.0'].iloc[-1]) if not bollinger_bands['BBL_20_2.0'].empty else None
-                if all(key in volatility for key in ['bb_upper', 'bb_lower', 'bb_middle']):
-                    volatility['bb_width'] = (volatility['bb_upper'] - volatility['bb_lower']) / volatility['bb_middle']
-        
+                if not bollinger_bands['BBU_20_2.0'].empty: volatility['bb_upper'] = float(bollinger_bands['BBU_20_2.0'].iloc[-1])
+                if not bollinger_bands['BBM_20_2.0'].empty: volatility['bb_middle'] = float(bollinger_bands['BBM_20_2.0'].iloc[-1])
+                if not bollinger_bands['BBL_20_2.0'].empty: volatility['bb_lower'] = float(bollinger_bands['BBL_20_2.0'].iloc[-1])
+                if all(key in volatility for key in ['bb_upper', 'bb_lower', 'bb_middle']): volatility['bb_width'] = (volatility['bb_upper'] - volatility['bb_lower']) / volatility['bb_middle']
         if len(dataframe) >= 14:
             average_true_range = ta.atr(dataframe['high'], dataframe['low'], dataframe['close'], length=14)
-            volatility['atr'] = float(average_true_range.iloc[-1]) if not average_true_range.empty else None
-            if volatility['atr']: 
-                volatility['atr_percent'] = volatility['atr'] / dataframe['close'].iloc[-1]
-        
+            if not average_true_range.empty: 
+                volatility['atr'] = float(average_true_range.iloc[-1])
+                if volatility['atr']: volatility['atr_percent'] = volatility['atr'] / dataframe['close'].iloc[-1]
         if len(dataframe) >= 20:
             keltner_channel = ta.kc(dataframe['high'], dataframe['low'], dataframe['close'], length=20)
             if keltner_channel is not None:
-                volatility['kc_upper'] = float(keltner_channel['KCUe_20_2'].iloc[-1]) if not keltner_channel['KCUe_20_2'].empty else None
-                volatility['kc_lower'] = float(keltner_channel['KCLe_20_2'].iloc[-1]) if not keltner_channel['KCLe_20_2'].empty else None
-        
+                if not keltner_channel['KCUe_20_2'].empty: volatility['kc_upper'] = float(keltner_channel['KCUe_20_2'].iloc[-1])
+                if not keltner_channel['KCLe_20_2'].empty: volatility['kc_lower'] = float(keltner_channel['KCLe_20_2'].iloc[-1])
         if len(dataframe) >= 20:
             donchian_channel = ta.donchian(dataframe['high'], dataframe['low'], length=20)
             if donchian_channel is not None:
-                volatility['dc_upper'] = float(donchian_channel['DCU_20_20'].iloc[-1]) if not donchian_channel['DCU_20_20'].empty else None
-                volatility['dc_lower'] = float(donchian_channel['DCL_20_20'].iloc[-1]) if not donchian_channel['DCL_20_20'].empty else None
-        
+                if not donchian_channel['DCU_20_20'].empty: volatility['dc_upper'] = float(donchian_channel['DCU_20_20'].iloc[-1])
+                if not donchian_channel['DCL_20_20'].empty: volatility['dc_lower'] = float(donchian_channel['DCL_20_20'].iloc[-1])
         if len(dataframe) >= 14:
             relative_volatility_index = ta.rvi(dataframe['close'], length=14)
-            volatility['rvi'] = float(relative_volatility_index.iloc[-1]) if not relative_volatility_index.empty else None
+            if not relative_volatility_index.empty: volatility['rvi'] = float(relative_volatility_index.iloc[-1])
         return {key: value for key, value in volatility.items() if value is not None}
     
     def _calculate_volume_indicators(self, dataframe):
         volume = {}
         if len(dataframe) >= 1:
             volume_weighted_average_price = ta.vwap(dataframe['high'], dataframe['low'], dataframe['close'], dataframe['volume'])
-            volume['vwap'] = float(volume_weighted_average_price.iloc[-1]) if not volume_weighted_average_price.empty else None
-        
+            if not volume_weighted_average_price.empty: volume['vwap'] = float(volume_weighted_average_price.iloc[-1])
         on_balance_volume = ta.obv(dataframe['close'], dataframe['volume'])
-        volume['obv'] = float(on_balance_volume.iloc[-1]) if not on_balance_volume.empty else None
-        
+        if not on_balance_volume.empty: volume['obv'] = float(on_balance_volume.iloc[-1])
         if len(dataframe) >= 14:
             money_flow_index = ta.mfi(dataframe['high'], dataframe['low'], dataframe['close'], dataframe['volume'], length=14)
-            volume['mfi'] = float(money_flow_index.iloc[-1]) if not money_flow_index.empty else None
-        
+            if not money_flow_index.empty: volume['mfi'] = float(money_flow_index.iloc[-1])
         accumulation_distribution = ta.ad(dataframe['high'], dataframe['low'], dataframe['close'], dataframe['volume'])
-        volume['ad_line'] = float(accumulation_distribution.iloc[-1]) if not accumulation_distribution.empty else None
-        
+        if not accumulation_distribution.empty: volume['ad_line'] = float(accumulation_distribution.iloc[-1])
         if len(dataframe) >= 20:
             volume_oscillator = ta.pvo(dataframe['volume'])
-            if volume_oscillator is not None:
-                volume['volume_oscillator'] = float(volume_oscillator['PVO_12_26_9'].iloc[-1]) if not volume_oscillator['PVO_12_26_9'].empty else None
-        
+            if volume_oscillator is not None and not volume_oscillator['PVO_12_26_9'].empty: volume['volume_oscillator'] = float(volume_oscillator['PVO_12_26_9'].iloc[-1])
         volume['volume_avg_20'] = float(dataframe['volume'].tail(20).mean()) if len(dataframe) >= 20 else None
-        if volume['volume_avg_20'] and volume['volume_avg_20'] > 0:
-            volume['volume_ratio'] = float(dataframe['volume'].iloc[-1] / volume['volume_avg_20'])
+        if volume['volume_avg_20'] and volume['volume_avg_20'] > 0: volume['volume_ratio'] = float(dataframe['volume'].iloc[-1] / volume['volume_avg_20'])
         return {key: value for key, value in volume.items() if value is not None}
     
     def _calculate_cycle_indicators(self, dataframe):
         cycle = {}
         if len(dataframe) >= 9:
             hull_moving_average = ta.hma(dataframe['close'], length=9)
-            cycle['hull_ma'] = float(hull_moving_average.iloc[-1]) if not hull_moving_average.empty else None
-        
+            if not hull_moving_average.empty: cycle['hull_ma'] = float(hull_moving_average.iloc[-1])
         if len(dataframe) >= 10:
             supertrend = ta.supertrend(dataframe['high'], dataframe['low'], dataframe['close'], length=10, multiplier=3)
             if supertrend is not None:
-                cycle['supertrend'] = float(supertrend['SUPERT_10_3.0'].iloc[-1]) if not supertrend['SUPERT_10_3.0'].empty else None
-                cycle['supertrend_direction'] = float(supertrend['SUPERTd_10_3.0'].iloc[-1]) if not supertrend['SUPERTd_10_3.0'].empty else None
-        
+                if not supertrend['SUPERT_10_3.0'].empty: cycle['supertrend'] = float(supertrend['SUPERT_10_3.0'].iloc[-1])
+                if not supertrend['SUPERTd_10_3.0'].empty: cycle['supertrend_direction'] = float(supertrend['SUPERTd_10_3.0'].iloc[-1])
         if len(dataframe) >= 10:
             fisher_transform = ta.fisher(dataframe['high'], dataframe['low'], length=10)
-            if fisher_transform is not None:
-                cycle['fisher_transform'] = float(fisher_transform['FISHERT_10_1'].iloc[-1]) if not fisher_transform['FISHERT_10_1'].empty else None
+            if fisher_transform is not None and not fisher_transform['FISHERT_10_1'].empty: cycle['fisher_transform'] = float(fisher_transform['FISHERT_10_1'].iloc[-1])
         return {key: value for key, value in cycle.items() if value is not None}
 
 class PatternEnhancedStrategyEngine:
-    """محرك استراتيجيات محسن مع دعم متقدم للأنماط البيانية"""
-    
     def __init__(self, data_manager, learning_engine):
         self.data_manager = data_manager
         self.learning_engine = learning_engine
         self.pattern_success_tracker = PatternPerformanceTracker()
         
     async def enhance_strategy_with_patterns(self, strategy_scores, pattern_analysis, symbol):
-        """تعزيز درجات الاستراتيجية بناءً على تحليل الأنماط"""
-        if not pattern_analysis or pattern_analysis.get('pattern_detected') in ['no_clear_pattern', 'insufficient_data']:
-            return strategy_scores
-            
+        if not pattern_analysis or pattern_analysis.get('pattern_detected') in ['no_clear_pattern', 'insufficient_data']: return strategy_scores
         pattern_confidence = pattern_analysis.get('pattern_confidence', 0)
         pattern_name = pattern_analysis.get('pattern_detected', '')
         predicted_direction = pattern_analysis.get('predicted_direction', '')
-        
-        # فقط تعزيز إذا كانت الثقة في النمط عالية
         if pattern_confidence >= 0.7:
             enhancement_factor = self._calculate_pattern_enhancement(pattern_confidence, pattern_name)
-            
-            # تحديد الاستراتيجيات المناسبة للنمط
             enhanced_strategies = self._get_pattern_appropriate_strategies(pattern_name, predicted_direction)
-            
             for strategy in enhanced_strategies:
                 if strategy in strategy_scores:
                     strategy_scores[strategy] *= enhancement_factor
-                    print(f"🎯 Enhanced {strategy} for {symbol} by {enhancement_factor:.1%} due to {pattern_name} pattern")
-        
         return strategy_scores
     
     def _calculate_pattern_enhancement(self, pattern_confidence, pattern_name):
-        """حساب عامل التعزيز بناءً على ثقة النمط ونوعه"""
-        base_enhancement = 1.0 + (pattern_confidence * 0.5)  # حتى 50% زيادة
-        
-        # أنماط عالية المصداقية تحصل على تعزيز إضافي
+        base_enhancement = 1.0 + (pattern_confidence * 0.5)
         high_reliability_patterns = ['Double Top', 'Double Bottom', 'Head & Shoulders', 'Cup and Handle']
-        if pattern_name in high_reliability_patterns:
-            base_enhancement *= 1.2
-            
-        return min(base_enhancement, 2.0)  # حد أقصى 100% زيادة
+        if pattern_name in high_reliability_patterns: base_enhancement *= 1.2
+        return min(base_enhancement, 2.0)
     
     def _get_pattern_appropriate_strategies(self, pattern_name, direction):
-        """الحصول على الاستراتيجيات المناسبة لنوع النمط"""
         reversal_patterns = ['Double Top', 'Double Bottom', 'Head & Shoulders', 'Triple Top', 'Triple Bottom']
         continuation_patterns = ['Flags', 'Pennants', 'Triangles', 'Rectangles']
-        
         if pattern_name in reversal_patterns:
-            if direction == 'down':
-                return ['breakout_momentum', 'trend_following']
-            else:
-                return ['mean_reversion', 'breakout_momentum']
-                
-        elif pattern_name in continuation_patterns:
-            return ['trend_following', 'breakout_momentum']
-            
-        else:  # أنماط أخرى
-            return ['breakout_momentum', 'hybrid_ai']
+            if direction == 'down': return ['breakout_momentum', 'trend_following']
+            else: return ['mean_reversion', 'breakout_momentum']
+        elif pattern_name in continuation_patterns: return ['trend_following', 'breakout_momentum']
+        else: return ['breakout_momentum', 'hybrid_ai']
 
 class PatternPerformanceTracker:
-    """متتبع أداء الأنماط البيانية"""
-    
     def __init__(self):
         self.pattern_performance = {}
         self.pattern_success_rates = {}
         
     async def track_pattern_outcome(self, symbol, pattern_analysis, success, profit_percent):
-        """تتبع نتيجة النمط البياني"""
-        if not pattern_analysis:
-            return
-            
+        if not pattern_analysis: return
         pattern_name = pattern_analysis.get('pattern_detected')
         confidence = pattern_analysis.get('pattern_confidence', 0)
-        
         if pattern_name not in ['no_clear_pattern', 'insufficient_data']:
             if pattern_name not in self.pattern_performance:
-                self.pattern_performance[pattern_name] = {
-                    'total_trades': 0,
-                    'successful_trades': 0,
-                    'total_profit': 0,
-                    'total_confidence': 0
-                }
-            
+                self.pattern_performance[pattern_name] = {'total_trades': 0,'successful_trades': 0,'total_profit': 0,'total_confidence': 0}
             stats = self.pattern_performance[pattern_name]
             stats['total_trades'] += 1
             stats['total_confidence'] += confidence
-            
             if success:
                 stats['successful_trades'] += 1
                 stats['total_profit'] += profit_percent
-                
             success_rate = stats['successful_trades'] / stats['total_trades']
             avg_profit = stats['total_profit'] / stats['successful_trades'] if stats['successful_trades'] > 0 else 0
             avg_confidence = stats['total_confidence'] / stats['total_trades']
-            
-            print(f"📊 Pattern Performance: {pattern_name} - "
-                  f"Success: {success_rate:.1%} - Avg Profit: {avg_profit:.2f}% - "
-                  f"Avg Confidence: {avg_confidence:.1%}")
     
     def get_pattern_reliability(self, pattern_name):
-        """الحصول على موثوقية النمط"""
         if pattern_name in self.pattern_performance:
             stats = self.pattern_performance[pattern_name]
-            if stats['total_trades'] > 0:
-                return stats['successful_trades'] / stats['total_trades']
-        return 0.5  # قيمة افتراضية
+            if stats['total_trades'] > 0: return stats['successful_trades'] / stats['total_trades']
+        return 0.5
 
 class MultiStrategyEngine:
     def __init__(self, data_manager, learning_engine):
@@ -292,431 +220,242 @@ class MultiStrategyEngine:
         }
     
     async def evaluate_all_strategies(self, symbol_data, market_context):
-        """تقييم جميع الاستراتيجيات مع استخدام أوزان نظام التعلم - الإصدار المحسّن"""
         try:
-            # ✅ الحصول على الأوزان المحسنة من نظام التعلم
             market_condition = market_context.get('market_trend', 'sideways_market')
-            
-            # ✅ التحقق من وجود learning_engine وتهيئته
             if self.learning_engine and hasattr(self.learning_engine, 'initialized') and self.learning_engine.initialized:
-                try:
-                    optimized_weights = await self.learning_engine.get_optimized_strategy_weights(market_condition)
-                    print(f"🎯 الأوزان المستخدمة: {optimized_weights}")
-                except Exception as e:
-                    print(f"⚠️ فشل الحصول على الأوزان المحسنة: {e}")
+                try: optimized_weights = await self.learning_engine.get_optimized_strategy_weights(market_condition)
+                except Exception as e: 
+                    print(f"⚠️ Failed to get optimized weights: {e}")
                     optimized_weights = await self.get_default_weights()
             else:
-                print("⚠️ نظام التعلم غير متوفر، استخدام الأوزان الافتراضية")
+                print("⚠️ Learning engine not available, using default weights")
                 optimized_weights = await self.get_default_weights()
-            
             strategy_scores = {}
-            base_scores = {}  # ✅ تخزين الدرجات الأساسية
-            
-            # ✅ تقييم كل استراتيجية مع تطبيق الأوزان
+            base_scores = {}
             for strategy_name, strategy_function in self.strategies.items():
                 try: 
                     base_score = await strategy_function(symbol_data, market_context)
-                    base_scores[strategy_name] = base_score  # ✅ حفظ الدرجة الأساسية
-                    
-                    # ✅ تطبيق الوزن المحسن
+                    base_scores[strategy_name] = base_score
                     weight = optimized_weights.get(strategy_name, 0.1)
                     weighted_score = base_score * weight
-                    
                     strategy_scores[strategy_name] = min(weighted_score, 1.0)
-                    
-                    print(f"📊 {strategy_name}: {base_score:.3f} × {weight:.3f} = {weighted_score:.3f}")
-                    
                 except Exception as error:
                     print(f"⚠️ Strategy {strategy_name} failed: {error}")
                     base_score = await self._fallback_strategy_score(strategy_name, symbol_data, market_context)
                     base_scores[strategy_name] = base_score
                     strategy_scores[strategy_name] = base_score * optimized_weights.get(strategy_name, 0.1)
-            
-            # ✅ تعزيز الاستراتيجيات بناءً على تحليل الأنماط
             pattern_analysis = symbol_data.get('pattern_analysis')
-            if pattern_analysis:
-                strategy_scores = await self.pattern_enhancer.enhance_strategy_with_patterns(
-                    strategy_scores, pattern_analysis, symbol_data.get('symbol')
-                )
-            
-            # ✅ تحديد أفضل استراتيجية بناءً على الدرجات الأساسية (بدون أوزان)
+            if pattern_analysis: strategy_scores = await self.pattern_enhancer.enhance_strategy_with_patterns(strategy_scores, pattern_analysis, symbol_data.get('symbol'))
             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]
-                
                 symbol_data['recommended_strategy'] = best_strategy_name
                 symbol_data['strategy_confidence'] = best_strategy_score
-                
-                print(f"🏆 أفضل استراتيجية (أساسي): {best_strategy_name} بدرجة {best_strategy_score:.3f}")
-                
-                # ✅ تعزيز اختيار الاستراتيجية إذا كان هناك نمط عالي الثقة
-                if (pattern_analysis and 
-                    pattern_analysis.get('pattern_confidence', 0) > 0.7 and
-                    self._is_strategy_pattern_aligned(best_strategy_name, pattern_analysis)):
-                    
+                if (pattern_analysis and pattern_analysis.get('pattern_confidence', 0) > 0.7 and self._is_strategy_pattern_aligned(best_strategy_name, pattern_analysis)):
                     pattern_bonus = pattern_analysis.get('pattern_confidence', 0) * 0.3
                     enhanced_confidence = min(best_strategy_score + pattern_bonus, 1.0)
                     symbol_data['strategy_confidence'] = enhanced_confidence
-                    print(f"🎯 تعزيز ثقة الاستراتيجية بواسطة النمط: {enhanced_confidence:.3f}")
-            
-            return strategy_scores, base_scores  # ✅ إرجاع كلا النوعين
-            
+            return strategy_scores, base_scores
         except Exception as error:
-            print(f"❌ فشل تقييم الاستراتيجيات: {error}")
+            print(f"❌ Strategy evaluation failed: {error}")
             fallback_scores = await self.get_fallback_scores()
             return fallback_scores, fallback_scores
 
     def _is_strategy_pattern_aligned(self, strategy_name, pattern_analysis):
-        """التحقق من محاذاة الاستراتيجية مع النمط البياني"""
         pattern_direction = pattern_analysis.get('predicted_direction', '')
         pattern_type = pattern_analysis.get('pattern_detected', '')
-        
-        # استراتيجيات التوجه الصعودي
         bullish_strategies = ['trend_following', 'breakout_momentum']
-        # استراتيجيات التوجه الهبوطي  
         bearish_strategies = ['mean_reversion', 'breakout_momentum']
-        
-        if pattern_direction == 'up' and strategy_name in bullish_strategies:
-            return True
-        elif pattern_direction == 'down' and strategy_name in bearish_strategies:
-            return True
-            
+        if pattern_direction == 'up' and strategy_name in bullish_strategies: return True
+        elif pattern_direction == 'down' and strategy_name in bearish_strategies: return True
         return False
 
     async def get_default_weights(self):
-        """الأوزان الافتراضية عندما لا يتوفر نظام التعلم"""
-        return {
-            'trend_following': 0.15, 'mean_reversion': 0.12,
-            'breakout_momentum': 0.18, 'volume_spike': 0.10,
-            'whale_tracking': 0.20, 'pattern_recognition': 0.15,
-            'hybrid_ai': 0.10
-        }
+        return {'trend_following': 0.15, 'mean_reversion': 0.12,'breakout_momentum': 0.18, 'volume_spike': 0.10,'whale_tracking': 0.20, 'pattern_recognition': 0.15,'hybrid_ai': 0.10}
 
     async def get_fallback_scores(self):
-        """درجات احتياطية عند فشل التقييم"""
-        return {
-            'trend_following': 0.5, 'mean_reversion': 0.5,
-            'breakout_momentum': 0.5, 'volume_spike': 0.5,
-            'whale_tracking': 0.5, 'pattern_recognition': 0.5,
-            'hybrid_ai': 0.5
-        }
+        return {'trend_following': 0.5, 'mean_reversion': 0.5,'breakout_momentum': 0.5, 'volume_spike': 0.5,'whale_tracking': 0.5, 'pattern_recognition': 0.5,'hybrid_ai': 0.5}
 
     async def _trend_following_strategy(self, symbol_data, market_context):
-        """استراتيجية تتبع الاتجاه المحسنة - درجات أعلى"""
         try:
             score = 0.0
             indicators = symbol_data.get('advanced_indicators', {})
             timeframes = ['4h', '1h', '15m']
-            
             for timeframe in timeframes:
                 if timeframe in indicators:
                     timeframe_indicators = indicators[timeframe]
-                    
-                    # تحقق من محاذاة المتوسطات المتحركة
-                    if self._check_ema_alignment(timeframe_indicators): 
-                        score += 0.20  # ⬆️ زيادة من 0.15 إلى 0.20
-                    
-                    # مؤشر ADX للقوة الاتجاهية
+                    if self._check_ema_alignment(timeframe_indicators): score += 0.20
                     adx_value = timeframe_indicators.get('adx', 0)
-                    if adx_value > 20:  # ⬇️ تخفيض من 25 إلى 20
-                        score += 0.15  # ⬆️ زيادة من 0.1 إلى 0.15
-                    
-                    # تحليل الحجم
+                    if adx_value > 20: score += 0.15
                     volume_ratio = timeframe_indicators.get('volume_ratio', 0)
-                    if volume_ratio > 1.2:  # ⬇️ تخفيض من 1.5 إلى 1.2
-                        score += 0.10  # ⬆️ زيادة من 0.05 إلى 0.10
-            
-            # ✅ تعزيز بناءً على تحليل الأنماط
+                    if volume_ratio > 1.2: score += 0.10
             pattern_analysis = symbol_data.get('pattern_analysis')
-            if (pattern_analysis and 
-                pattern_analysis.get('pattern_confidence', 0) > 0.7 and
-                pattern_analysis.get('predicted_direction') == 'up'):
+            if (pattern_analysis and pattern_analysis.get('pattern_confidence', 0) > 0.7 and pattern_analysis.get('predicted_direction') == 'up'):
                 pattern_bonus = pattern_analysis.get('pattern_confidence', 0) * 0.2
                 score += pattern_bonus
-                print(f"📈 Trend following enhanced by pattern: +{pattern_bonus:.3f}")
-            
             return min(score, 1.0)
-            
         except Exception as error:
             print(f"⚠️ Trend following strategy error: {error}")
-            return 0.3  # ⬆️ زيادة من 0.3 إلى 0.3 (نفس القيمة)
+            return 0.3
     
     def _check_ema_alignment(self, indicators):
-        """التحقق من محاذاة المتوسطات المتحركة"""
         required_emas = ['ema_9', 'ema_21', 'ema_50']
-        if all(ema in indicators for ema in required_emas):
-            return (indicators['ema_9'] > indicators['ema_21'] > indicators['ema_50'])
+        if all(ema in indicators for ema in required_emas): return (indicators['ema_9'] > indicators['ema_21'] > indicators['ema_50'])
         return False
     
     async def _mean_reversion_strategy(self, symbol_data, market_context):
-        """استراتيجية العودة إلى المتوسط المحسنة - درجات أعلى"""
         try:
             score = 0.0
             current_price = symbol_data['current_price']
             indicators = symbol_data.get('advanced_indicators', {})
-            
             if '1h' in indicators:
                 hourly_indicators = indicators['1h']
-                
-                # تحليل Bollinger Bands
                 if all(key in hourly_indicators for key in ['bb_upper', 'bb_lower', 'bb_middle']):
                     position_in_band = (current_price - hourly_indicators['bb_lower']) / (hourly_indicators['bb_upper'] - hourly_indicators['bb_lower'])
-                    
-                    if position_in_band < 0.1 and hourly_indicators.get('rsi', 50) < 35: 
-                        score += 0.45  # ⬆️ زيادة من 0.4 إلى 0.45
-                    if position_in_band > 0.9 and hourly_indicators.get('rsi', 50) > 65: 
-                        score += 0.45  # ⬆️ زيادة من 0.4 إلى 0.45
-                
-                # تحليل RSI
+                    if position_in_band < 0.1 and hourly_indicators.get('rsi', 50) < 35: score += 0.45
+                    if position_in_band > 0.9 and hourly_indicators.get('rsi', 50) > 65: score += 0.45
                 rsi_value = hourly_indicators.get('rsi', 50)
-                if rsi_value < 30: 
-                    score += 0.35  # ⬆️ زيادة من 0.3 إلى 0.35
-                elif rsi_value > 70: 
-                    score += 0.35  # ⬆️ زيادة من 0.3 إلى 0.35
-            
-            # ✅ تعزيز بناءً على تحليل الأنماط
+                if rsi_value < 30: score += 0.35
+                elif rsi_value > 70: score += 0.35
             pattern_analysis = symbol_data.get('pattern_analysis')
-            if (pattern_analysis and 
-                pattern_analysis.get('pattern_confidence', 0) > 0.7 and
-                pattern_analysis.get('predicted_direction') in ['up', 'down']):
+            if (pattern_analysis and pattern_analysis.get('pattern_confidence', 0) > 0.7 and pattern_analysis.get('predicted_direction') in ['up', 'down']):
                 pattern_bonus = pattern_analysis.get('pattern_confidence', 0) * 0.15
                 score += pattern_bonus
-                print(f"🔄 Mean reversion enhanced by pattern: +{pattern_bonus:.3f}")
-            
             return min(score, 1.0)
-            
         except Exception as error:
             print(f"⚠️ Mean reversion strategy error: {error}")
             return 0.3
     
     async def _breakout_momentum_strategy(self, symbol_data, market_context):
-        """استراتيجية كسر الزخم المحسنة - درجات أعلى"""
         try:
             score = 0.0
             indicators = symbol_data.get('advanced_indicators', {})
-            
-            for timeframe in ['1h', '15m', '5m']:  # ✅ إضافة timeframe إضافية
+            for timeframe in ['1h', '15m', '5m']:
                 if timeframe in indicators:
                     timeframe_indicators = indicators[timeframe]
-                    
-                    # ✅ تحليل الحجم - عتبات مخفضة
                     volume_ratio = timeframe_indicators.get('volume_ratio', 0)
-                    if volume_ratio > 1.8:  # ⬇️ تخفيض من 2.0 إلى 1.8
-                        score += 0.25  # ⬆️ زيادة من 0.2 إلى 0.25
-                    elif volume_ratio > 1.3:  # ✅ إضافة شرط وسيط
-                        score += 0.15
-                    
-                    # ✅ تحليل MACD
-                    if timeframe_indicators.get('macd_hist', 0) > 0:
-                        score += 0.20  # ⬆️ زيادة من 0.15 إلى 0.20
-                    
-                    # ✅ تحليل VWAP
-                    if 'vwap' in timeframe_indicators and symbol_data['current_price'] > timeframe_indicators['vwap']:
-                        score += 0.15  # ⬆️ زيادة من 0.1 إلى 0.15
-                    
-                    # ✅ إضافة شرط RSI إضافي
+                    if volume_ratio > 1.8: score += 0.25
+                    elif volume_ratio > 1.3: score += 0.15
+                    if timeframe_indicators.get('macd_hist', 0) > 0: score += 0.20
+                    if 'vwap' in timeframe_indicators and symbol_data['current_price'] > timeframe_indicators['vwap']: score += 0.15
                     rsi_value = timeframe_indicators.get('rsi', 50)
-                    if 40 <= rsi_value <= 70:  # نطاق RSI صحي
-                        score += 0.10
-            
-            # ✅ تعزيز بناءً على تحليل الأنماط - تأثير كبير على breakout
+                    if 40 <= rsi_value <= 70: score += 0.10
             pattern_analysis = symbol_data.get('pattern_analysis')
             if pattern_analysis and pattern_analysis.get('pattern_confidence', 0) > 0.6:
                 pattern_bonus = pattern_analysis.get('pattern_confidence', 0) * 0.3
                 score += pattern_bonus
-                print(f"🚀 Breakout momentum significantly enhanced by pattern: +{pattern_bonus:.3f}")
-            
-            # ✅ ضمان حد أدنى للدرجة إذا كانت هناك إشارات إيجابية
-            if score > 0.2:
-                score = max(score, 0.4)  # ⬆️ ضمان حد أدنى 0.4 إذا كانت هناك إشارات
-                
+            if score > 0.2: score = max(score, 0.4)
             return min(score, 1.0)
-            
         except Exception as error:
             print(f"⚠️ Breakout momentum strategy error: {error}")
-            return 0.4  # ⬆️ زيادة من 0.3 إلى 0.4
+            return 0.4
     
     async def _volume_spike_strategy(self, symbol_data, market_context):
-        """استراتيجية ارتفاع الحجم المحسنة - درجات أعلى"""
         try:
             score = 0.0
             indicators = symbol_data.get('advanced_indicators', {})
-            
             for timeframe in ['1h', '15m', '5m']:
                 if timeframe in indicators:
                     volume_ratio = indicators[timeframe].get('volume_ratio', 0)
-                    if volume_ratio > 3.0: 
-                        score += 0.45  # ⬆️ زيادة من 0.4 إلى 0.45
-                    elif volume_ratio > 2.0: 
-                        score += 0.25  # ⬆️ زيادة من 0.2 إلى 0.25
-                    elif volume_ratio > 1.5:  # ✅ إضافة شرط وسيط
-                        score += 0.15
-            
-            # ✅ تعزيز بناءً على تحليل الأنماط مع ارتفاع الحجم
+                    if volume_ratio > 3.0: score += 0.45
+                    elif volume_ratio > 2.0: score += 0.25
+                    elif volume_ratio > 1.5: score += 0.15
             pattern_analysis = symbol_data.get('pattern_analysis')
-            if (pattern_analysis and 
-                pattern_analysis.get('pattern_confidence', 0) > 0.7 and
-                any(indicators[tf].get('volume_ratio', 0) > 2.0 for tf in ['1h', '15m'] if tf in indicators)):
+            if (pattern_analysis and pattern_analysis.get('pattern_confidence', 0) > 0.7 and any(indicators[tf].get('volume_ratio', 0) > 2.0 for tf in ['1h', '15m'] if tf in indicators)):
                 pattern_bonus = pattern_analysis.get('pattern_confidence', 0) * 0.2
                 score += pattern_bonus
-                print(f"💧 Volume spike enhanced by pattern: +{pattern_bonus:.3f}")
-            
             return min(score, 1.0)
-            
         except Exception as error:
             print(f"⚠️ Volume spike strategy error: {error}")
             return 0.3
     
     async def _whale_tracking_strategy(self, symbol_data, market_context):
-        """استراتيجية تتبع الحيتان المحسنة - درجات أعلى"""
         try:
             score = 0.0
-            # ✅ الإصلاح: استخدام الدالة الآمنة الجديدة
             whale_data = await self.data_manager.get_whale_data_safe_async(symbol_data['symbol'])
-            
-            # استخدام البيانات الحقيقية فقط
-            if not whale_data.get('data_available', False):
-                return 0.2  # ⬆️ زيادة من 0.1 إلى 0.2 (قيمة أساسية أعلى)
-                
+            if not whale_data.get('data_available', False): return 0.2
             total_transactions = whale_data.get('transfer_count', 0)
             whale_volume = whale_data.get('total_volume', 0)
-            
-            # ✅ معايير مرنة للسماح بمزيد من المرشحين
-            if total_transactions >= 2:  # ⬇️ تخفيض من 3 إلى 2
-                score += 0.35  # ⬆️ زيادة من 0.3 إلى 0.35
-            elif total_transactions >= 1:  # ⬇️ تخفيض من 5 إلى 1
-                score += 0.25  # ⬆️ زيادة من 0.15 إلى 0.25
-                
-            if whale_volume > 25000:  # ⬇️ تخفيض من 50000 إلى 25000
-                score += 0.25  # ⬆️ زيادة من 0.2 إلى 0.25
-            elif whale_volume > 5000:  # ⬇️ تخفيض من 10000 إلى 5000
-                score += 0.15  # ⬆️ زيادة من 0.1 إلى 0.15
-                
-            # ✅ إضافة نقاط إضافية بناءً على نشاط الحيتان العام
+            if total_transactions >= 2: score += 0.35
+            elif total_transactions >= 1: score += 0.25
+            if whale_volume > 25000: score += 0.25
+            elif whale_volume > 5000: score += 0.15
             general_whale = market_context.get('general_whale_activity', {})
-            if general_whale.get('data_available', False) and general_whale.get('transaction_count', 0) > 0:
-                score += 0.15  # ⬆️ زيادة من 0.1 إلى 0.15
-                
+            if general_whale.get('data_available', False) and general_whale.get('transaction_count', 0) > 0: score += 0.15
             return min(score, 1.0)
-            
         except Exception as error: 
             print(f"⚠️ Whale tracking failed: {error}")
-            return 0.2  # ⬆️ زيادة من 0.1 إلى 0.2
+            return 0.2
     
     async def _pattern_recognition_strategy(self, symbol_data, market_context):
-        """استراتيجية التعرف على الأنماط المحسنة - درجات أعلى"""
         try:
             score = 0.0
             indicators = symbol_data.get('advanced_indicators', {})
-            
-            # ✅ تعزيز كبير بناءً على تحليل الأنماط من LLM
             pattern_analysis = symbol_data.get('pattern_analysis')
             if pattern_analysis and pattern_analysis.get('pattern_confidence', 0) > 0.6:
                 score += pattern_analysis.get('pattern_confidence', 0) * 0.8
-                print(f"🎯 Pattern recognition significantly enhanced: +{score:.3f}")
             else:
-                # التحليل التقليدي إذا لم يكن هناك نمط من LLM
                 for timeframe in ['4h', '1h']:
                     if timeframe in indicators:
                         timeframe_indicators = indicators[timeframe]
-                        
-                        # نمط الزخم الصعودي
-                        if (timeframe_indicators.get('rsi', 50) > 60 and 
-                            timeframe_indicators.get('macd_hist', 0) > 0 and 
-                            timeframe_indicators.get('volume_ratio', 0) > 1.5): 
-                            score += 0.35  # ⬆️ زيادة من 0.3 إلى 0.35
-                        
-                        # نمط الزخم الهبوطي
-                        if (timeframe_indicators.get('rsi', 50) < 40 and 
-                            timeframe_indicators.get('stoch_rsi_k', 50) < 20): 
-                            score += 0.35  # ⬆️ زيادة من 0.3 إلى 0.35
-            
+                        if (timeframe_indicators.get('rsi', 50) > 60 and timeframe_indicators.get('macd_hist', 0) > 0 and timeframe_indicators.get('volume_ratio', 0) > 1.5): score += 0.35
+                        if (timeframe_indicators.get('rsi', 50) < 40 and timeframe_indicators.get('stoch_rsi_k', 50) < 20): score += 0.35
             return min(score, 1.0)
-            
         except Exception as error:
             print(f"⚠️ Pattern recognition strategy error: {error}")
             return 0.3
     
     async def _hybrid_ai_strategy(self, symbol_data, market_context):
-        """استراتيجية الهجين الذكية المحسنة - درجات أعلى"""
         try:
             score = 0.0
             monte_carlo_probability = symbol_data.get('monte_carlo_probability', 0.5)
             final_score = symbol_data.get('final_score', 0.5)
-            
             score += monte_carlo_probability * 0.4
             score += final_score * 0.3
-            
-            # تحليل سياق السوق
-            if market_context.get('btc_sentiment') == 'BULLISH': 
-                score += 0.25  # ⬆️ زيادة من 0.2 إلى 0.25
-            elif market_context.get('btc_sentiment') == 'BEARISH': 
-                score -= 0.08  # ⬆️ تخفيض من 0.1 إلى 0.08
-            
-            # تحليل نشاط الحيتان العام
+            if market_context.get('btc_sentiment') == 'BULLISH': score += 0.25
+            elif market_context.get('btc_sentiment') == 'BEARISH': score -= 0.08
             whale_activity = market_context.get('general_whale_activity', {})
-            if whale_activity.get('sentiment') == 'BULLISH':
-                score += 0.15  # ⬆️ زيادة من 0.1 إلى 0.15
-            
-            # ✅ تعزيز بناءً على تحليل الأنماط
+            if whale_activity.get('sentiment') == 'BULLISH': score += 0.15
             pattern_analysis = symbol_data.get('pattern_analysis')
             if pattern_analysis and pattern_analysis.get('pattern_confidence', 0) > 0.7:
                 pattern_bonus = pattern_analysis.get('pattern_confidence', 0) * 0.25
                 score += pattern_bonus
-                print(f"🤖 Hybrid AI enhanced by pattern: +{pattern_bonus:.3f}")
-            
             return max(0.0, min(score, 1.0))
-            
         except Exception as error:
             print(f"⚠️ Hybrid AI strategy error: {error}")
             return 0.3
     
     async def _fallback_strategy_score(self, strategy_name, symbol_data, market_context):
-        """درجات استراتيجية احتياطية محسنة"""
         try:
             base_score = symbol_data.get('final_score', 0.5)
-            
             if strategy_name == 'trend_following':
                 indicators = symbol_data.get('advanced_indicators', {})
                 if '1h' in indicators:
                     rsi_value = indicators['1h'].get('rsi', 50)
                     ema_9 = indicators['1h'].get('ema_9')
                     ema_21 = indicators['1h'].get('ema_21')
-                    
-                    if ema_9 and ema_21 and ema_9 > ema_21 and 40 <= rsi_value <= 60: 
-                        return 0.6
+                    if ema_9 and ema_21 and ema_9 > ema_21 and 40 <= rsi_value <= 60: return 0.6
                 return 0.4
-                
             elif strategy_name == 'mean_reversion':
                 current_price = symbol_data.get('current_price', 0)
                 indicators = symbol_data.get('advanced_indicators', {})
                 if '1h' in indicators:
                     rsi_value = indicators['1h'].get('rsi', 50)
                     bb_lower = indicators['1h'].get('bb_lower')
-                    
-                    if bb_lower and current_price <= bb_lower * 1.02 and rsi_value < 35:
-                        return 0.7
+                    if bb_lower and current_price <= bb_lower * 1.02 and rsi_value < 35: return 0.7
                 return 0.3
-                
             elif strategy_name == 'breakout_momentum':
                 volume_ratio = symbol_data.get('advanced_indicators', {}).get('1h', {}).get('volume_ratio', 0)
-                if volume_ratio > 1.5: 
-                    return 0.6
+                if volume_ratio > 1.5: return 0.6
                 return 0.4
-                
             elif strategy_name == 'whale_tracking':
                 whale_data = symbol_data.get('whale_data', {})
-                if not whale_data.get('data_available', False):
-                    return 0.2  # ⬆️ زيادة من 0.1 إلى 0.2
-                    
+                if not whale_data.get('data_available', False): return 0.2
                 total_transactions = whale_data.get('transfer_count', 0)
-                if total_transactions >= 3: 
-                    return 0.5
+                if total_transactions >= 3: return 0.5
                 return 0.3
-                
             return base_score
-            
         except Exception as error:
             print(f"⚠️ Fallback strategy failed for {strategy_name}: {error}")
             return 0.3
@@ -731,10 +470,8 @@ class MLProcessor:
         self.pattern_tracker = PatternPerformanceTracker()
     
     def _validate_rsi_safety(self, indicators):
-        """التحقق العاجل من سلامة مؤشر RSI"""
         rsi_warnings = []
         critical_issues = 0
-        
         timeframes_to_check = ['5m', '15m', '1h', '4h']
         for timeframe in timeframes_to_check:
             if timeframe in indicators:
@@ -743,191 +480,106 @@ class MLProcessor:
                     if rsi_value > 80:
                         rsi_warnings.append(f"🚨 RSI CRITICAL in {timeframe}: {rsi_value} - EXTREME OVERBOUGHT")
                         critical_issues += 1
-                    elif rsi_value > 75:
-                        rsi_warnings.append(f"⚠️ RSI WARNING in {timeframe}: {rsi_value} - STRONG OVERBOUGHT")
-                    elif rsi_value > 70:
-                        rsi_warnings.append(f"📈 RSI HIGH in {timeframe}: {rsi_value} - OVERBOUGHT")
-        
-        # إذا كان هناك إطارين زمنيين أو أكثر في منطقة الخطر، نرفض المرشح
+                    elif rsi_value > 75: rsi_warnings.append(f"⚠️ RSI WARNING in {timeframe}: {rsi_value} - STRONG OVERBOUGHT")
+                    elif rsi_value > 70: rsi_warnings.append(f"📈 RSI HIGH in {timeframe}: {rsi_value} - OVERBOUGHT")
         is_safe = critical_issues < 2
         return is_safe, rsi_warnings
     
     def _validate_indicators_quality_enhanced(self, indicators, current_price):
-        """تحسين التحقق من جودة المؤشرات"""
         quality_issues = []
-        
-        # التحقق من RSI
         rsi_safe, rsi_warnings = self._validate_rsi_safety(indicators)
-        if not rsi_safe:
-            quality_issues.extend(rsi_warnings)
-        
-        # التحقق من تناقض المؤشرات
-        bullish_signals = 0
-        bearish_signals = 0
-        
+        if not rsi_safe: quality_issues.extend(rsi_warnings)
+        bullish_signals = bearish_signals = 0
         for timeframe, data in indicators.items():
-            # إشارات صعودية
-            if data.get('macd_hist', 0) > 0:
-                bullish_signals += 1
-            if data.get('rsi', 50) > 70:  # RSI مرتفع يعتبر إشارة بيع
-                bearish_signals += 1
+            if data.get('macd_hist', 0) > 0: bullish_signals += 1
+            if data.get('rsi', 50) > 70: bearish_signals += 1
             if 'ema_9' in data and 'ema_21' in data:
-                if data['ema_9'] > data['ema_21']:
-                    bullish_signals += 1
-        
-        if bullish_signals > 0 and bearish_signals > bullish_signals:
-            quality_issues.append("⚠️ Conflicting signals: More bearish than bullish indicators")
-        
+                if data['ema_9'] > data['ema_21']: bullish_signals += 1
+        if bullish_signals > 0 and bearish_signals > bullish_signals: quality_issues.append("⚠️ Conflicting signals: More bearish than bullish indicators")
         return quality_issues
     
     def _calculate_enhanced_score_with_safety(self, base_analysis, strategy_scores, quality_issues):
-        """حساب النقاط مع مراعاة عوامل السلامة"""
         base_score = base_analysis.get('final_score', 0.5)
         strategy_average = sum(strategy_scores.values()) / len(strategy_scores) if strategy_scores else 0.5
-        
-        # خصم النقاط بناءً على مشاكل الجودة
         safety_penalty = 0.0
         for issue in quality_issues:
-            if '🚨 RSI CRITICAL' in issue:
-                safety_penalty += 0.3
-            elif '⚠️ RSI WARNING' in issue:
-                safety_penalty += 0.15
-            elif '📈 RSI HIGH' in issue:
-                safety_penalty += 0.05
-        
+            if '🚨 RSI CRITICAL' in issue: safety_penalty += 0.3
+            elif '⚠️ RSI WARNING' in issue: safety_penalty += 0.15
+            elif '📈 RSI HIGH' in issue: safety_penalty += 0.05
         enhanced_score = (base_score * 0.4) + (strategy_average * 0.6)
         enhanced_score = max(0.0, enhanced_score - safety_penalty)
-        
         return min(enhanced_score, 1.0)
     
     async def process_and_score_symbol_enhanced(self, raw_data):
-        """معالجة وتحليل الرمز مع نظام التعلم والاستراتيجيات - الإصدار المحسّن"""
         try:
-            if not raw_data or not raw_data.get('ohlcv'):
-                print(f"⚠️ Skipping {raw_data.get('symbol', 'unknown')} - no OHLCV data")
-                return None
-            
-            # ✅ تمرير بيانات الشموع الخام للتحليل اللاحق
+            if not raw_data or not raw_data.get('ohlcv'): return None
             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: 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
-                )
-                
-                # طباعة تحذيرات الجودة
+                quality_issues = self._validate_indicators_quality_enhanced(base_analysis.get('advanced_indicators', {}), current_price)
                 if quality_issues:
                     print(f"🔍 Quality issues for {base_analysis.get('symbol')}:")
-                    for issue in quality_issues:
-                        print(f"   {issue}")
-                
-                # ✅ تقييم الاستراتيجيات باستخدام نظام التعلم مع التحقق من الوجود
+                    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  # ✅ حفظ الدرجات الأساسية
-                    
-                    # ✅ تحديد أفضل استراتيجية بناءً على الدرجات الأساسية (بدون أوزان)
+                    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
-                        
-                        print(f"🎯 أفضل استراتيجية لـ {base_analysis.get('symbol')}: {best_strategy_name} (ثقة: {best_strategy_score:.3f})")
-                        
-                        # ✅ تخفيض عتبة الثقة للسماح بمزيد من الاستراتيجيات
-                        if best_strategy_score > 0.3:  # ⬇️ تخفيض من 0.6 إلى 0.3
-                            base_analysis['target_strategy'] = best_strategy_name
-                            print(f"✅ استخدام استراتيجية متخصصة: {best_strategy_name}")
-                        else:
-                            base_analysis['target_strategy'] = 'GENERIC'
-                            print(f"🔄 استخدام استراتيجية عامة (ثقة منخفضة: {best_strategy_score:.3f})")
+                        if best_strategy_score > 0.3: base_analysis['target_strategy'] = best_strategy_name
+                        else: base_analysis['target_strategy'] = 'GENERIC'
                     else:
                         base_analysis['recommended_strategy'] = 'GENERIC'
-                        base_analysis['strategy_confidence'] = 0.3  # ⬆️ زيادة من 0.5 إلى 0.3
+                        base_analysis['strategy_confidence'] = 0.3
                         base_analysis['target_strategy'] = 'GENERIC'
-                        print("🔄 استخدام استراتيجية عامة (لا توجد درجات استراتيجية)")
-                    
-                    # ✅ استخدام الدالة المحسنة لحساب النقاط
-                    enhanced_score = self._calculate_enhanced_score_with_safety(
-                        base_analysis, strategy_scores, quality_issues
-                    )
-                    
+                    enhanced_score = self._calculate_enhanced_score_with_safety(base_analysis, strategy_scores, quality_issues)
                     base_analysis['enhanced_final_score'] = enhanced_score
                 else:
-                    print("⚠️ Strategy engine not available, using base analysis only")
                     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'] = quality_issues
-                
             except Exception as strategy_error:
                 print(f"⚠️ Strategy evaluation failed for {base_analysis.get('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  # ⬆️ زيادة من 0.5 إلى 0.3
+                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"❌ Enhanced processing failed for {raw_data.get('symbol')}: {error}")
             return await self.process_and_score_symbol(raw_data)
 
     def _improve_fibonacci_levels(self, daily_dataframe, current_price):
-        """تحسين حساب مستويات Fibonacci لتتوافق مع السعر الحالي"""
-        if len(daily_dataframe) < 50: 
-            return {}
-        
-        # استخدام آخر 50 يومًا لحساب القمة والقاع
+        if len(daily_dataframe) < 50: return {}
         recent_high = float(daily_dataframe['high'].iloc[-50:].max())
         recent_low = float(daily_dataframe['low'].iloc[-50:].min())
-        
-        # إذا كان السعر الحالي خارج النطاق، نعدل النطاق
-        if current_price > recent_high:
-            recent_high = current_price * 1.05  # نضيف هامش 5%
-        if current_price < recent_low:
-            recent_low = current_price * 0.95   # نخصم هامش 5%
-        
+        if current_price > recent_high: recent_high = current_price * 1.05
+        if current_price < recent_low: recent_low = current_price * 0.95
         difference = recent_high - recent_low
-        if difference <= 0:  # تجنب القسمة على الصفر
-            return {}
-            
+        if difference <= 0: return {}
         return {
-            "0.0%": recent_high,
-            "23.6%": recent_high - 0.236 * difference,
-            "38.2%": recent_high - 0.382 * difference,
-            "50.0%": recent_high - 0.50 * difference,
-            "61.8%": recent_high - 0.618 * difference,
-            "78.6%": recent_high - 0.786 * difference,
+            "0.0%": recent_high, "23.6%": recent_high - 0.236 * difference,
+            "38.2%": recent_high - 0.382 * difference, "50.0%": recent_high - 0.50 * difference,
+            "61.8%": recent_high - 0.618 * difference, "78.6%": recent_high - 0.786 * difference,
             "100.0%": recent_low
         }
     
     async def process_and_score_symbol(self, raw_data):
-        """معالجة وتحليل الرمز الأساسي"""
         symbol = raw_data['symbol']
         ohlcv_data = raw_data['ohlcv']
         reasons_for_candidacy = raw_data.get('reasons', [])
-        
-        if not ohlcv_data: 
-            print(f"❌ No OHLCV data for {symbol}")
-            return None
-            
+        if not ohlcv_data: return None
         try:
             all_indicators = {}
             for timeframe, candles in ohlcv_data.items():
@@ -935,14 +587,9 @@ class MLProcessor:
                     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: 
-                print(f"❌ Skipping {symbol} due to insufficient 1h data.")
-                return None
-                
+            if hourly_dataframe.empty: 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'):
@@ -950,40 +597,22 @@ 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
                 fibonacci_levels = self._improve_fibonacci_levels(daily_dataframe, current_price)
-                
-                try: 
-                    whale_data = await self.data_manager.get_whale_data_safe_async(symbol)
+                try: whale_data = await self.data_manager.get_whale_data_safe_async(symbol)
                 except Exception as whale_error:
-                    print(f"⚠️ Whale data failed for {symbol}: {whale_error}. No whale data available.")
-                    whale_data = {
-                        "transfer_count": 0, 
-                        "total_volume": 0, 
-                        "source": "no_data",
-                        "data_available": False
-                    }
-                    
+                    print(f"⚠️ Whale data failed for {symbol}: {whale_error}.")
+                    whale_data = {"transfer_count": 0, "total_volume": 0, "source": "no_data", "data_available": False}
                 whale_score = self._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)
                 monte_carlo_probability = self._run_monte_carlo_simulation(hourly_dataframe)
-                
-                print(f"🎲 Monte Carlo Simulation for {symbol}: Success Probability = {monte_carlo_probability:.2%}")
-                
                 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()}
-                
                 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),
@@ -992,25 +621,16 @@ class MLProcessor:
                     'initial_score': float(initial_score), 'monte_carlo_probability': float(monte_carlo_probability),
                     'indicators': normalized_indicators, 'advanced_indicators': all_indicators, 'strategy_scores': {},
                     'recommended_strategy': 'GENERIC', 'enhanced_final_score': float(final_score), 'target_strategy': 'GENERIC',
-                    'raw_ohlcv': ohlcv_data  # ✅ إضافة بيانات الشموع الخام
+                    'raw_ohlcv': ohlcv_data
                 }
-                
-            except (KeyError, IndexError) as error: 
-                print(f"⚠️ Missing data for {symbol}: {error}")
-                return None
-                
+            except (KeyError, IndexError) as error: return None
         except Exception as error: 
             print(f"❌ Failed to process {symbol}: {error}")
-            import traceback
-            traceback.print_exc()
             return None
 
     def _calculate_indicators(self, dataframe, timeframe):
-        """حساب المؤشرات الفنية"""
         indicators = {}
-        if dataframe.empty: 
-            return indicators
-            
+        if dataframe.empty: return indicators
         if not isinstance(dataframe.index, pd.DatetimeIndex):
             try:
                 dataframe['time'] = pd.to_datetime(dataframe['time'], unit='ms')
@@ -1018,88 +638,56 @@ class MLProcessor:
             except: 
                 dataframe['time'] = pd.to_datetime(dataframe['time'])
                 dataframe = dataframe.set_index('time', drop=True)
-                
         dataframe = dataframe.sort_index()
-        
         if len(dataframe) >= 1 and all(column in dataframe.columns for column in ['high', 'low', 'close', 'volume']):
             try:
                 typical_price = (dataframe['high'] + dataframe['low'] + dataframe['close']) / 3
                 volume_weighted_average_price = (typical_price * dataframe['volume']).cumsum() / dataframe['volume'].cumsum()
-                if not volume_weighted_average_price.empty and not pd.isna(volume_weighted_average_price.iloc[-1]): 
-                    indicators['vwap'] = float(volume_weighted_average_price.iloc[-1])
-            except Exception as error: 
-                print(f"⚠️ VWAP calculation failed for {timeframe}: {error}")
-                
+                if not volume_weighted_average_price.empty and not pd.isna(volume_weighted_average_price.iloc[-1]): indicators['vwap'] = float(volume_weighted_average_price.iloc[-1])
+            except Exception as error: pass
         if len(dataframe) >= 14:
             rsi_series = ta.rsi(dataframe['close'], length=14)
-            if rsi_series is not None and not rsi_series.empty and rsi_series.iloc[-1] is not np.nan: 
-                indicators['rsi'] = float(rsi_series.iloc[-1])
-                
+            if rsi_series is not None and not rsi_series.empty and rsi_series.iloc[-1] is not np.nan: indicators['rsi'] = float(rsi_series.iloc[-1])
         if len(dataframe) >= 26:
             macd = ta.macd(dataframe['close'])
             if macd is not None and not macd.empty:
-                if 'MACDh_12_26_9' in macd.columns and macd['MACDh_12_26_9'].iloc[-1] is not np.nan: 
-                    indicators['macd_hist'] = float(macd['MACDh_12_26_9'].iloc[-1])
-                if 'MACD_12_26_9' in macd.columns and macd['MACD_12_26_9'].iloc[-1] is not np.nan: 
-                    indicators['macd_line'] = float(macd['MACD_12_26_9'].iloc[-1])
-                if 'MACDs_12_26_9' in macd.columns and macd['MACDs_12_26_9'].iloc[-1] is not np.nan: 
-                    indicators['macd_signal'] = float(macd['MACDs_12_26_9'].iloc[-1])
-                    
+                if 'MACDh_12_26_9' in macd.columns and macd['MACDh_12_26_9'].iloc[-1] is not np.nan: indicators['macd_hist'] = float(macd['MACDh_12_26_9'].iloc[-1])
+                if 'MACD_12_26_9' in macd.columns and macd['MACD_12_26_9'].iloc[-1] is not np.nan: indicators['macd_line'] = float(macd['MACD_12_26_9'].iloc[-1])
+                if 'MACDs_12_26_9' in macd.columns and macd['MACDs_12_26_9'].iloc[-1] is not np.nan: indicators['macd_signal'] = float(macd['MACDs_12_26_9'].iloc[-1])
         if len(dataframe) >= 20:
             bollinger_bands = ta.bbands(dataframe['close'], length=20, std=2)
             if bollinger_bands is not None and not bollinger_bands.empty:
-                if 'BBL_20_2.0' in bollinger_bands.columns and bollinger_bands['BBL_20_2.0'].iloc[-1] is not np.nan: 
-                    indicators['bb_lower'] = float(bollinger_bands['BBL_20_2.0'].iloc[-1])
-                if 'BBU_20_2.0' in bollinger_bands.columns and bollinger_bands['BBU_20_2.0'].iloc[-1] is not np.nan: 
-                    indicators['bb_upper'] = float(bollinger_bands['BBU_20_2.0'].iloc[-1])
-                if 'BBM_20_2.0' in bollinger_bands.columns and bollinger_bands['BBM_20_2.0'].iloc[-1] is not np.nan: 
-                    indicators['bb_middle'] = float(bollinger_bands['BBM_20_2.0'].iloc[-1])
-                    
+                if 'BBL_20_2.0' in bollinger_bands.columns and bollinger_bands['BBL_20_2.0'].iloc[-1] is not np.nan: indicators['bb_lower'] = float(bollinger_bands['BBL_20_2.0'].iloc[-1])
+                if 'BBU_20_2.0' in bollinger_bands.columns and bollinger_bands['BBU_20_2.0'].iloc[-1] is not np.nan: indicators['bb_upper'] = float(bollinger_bands['BBU_20_2.0'].iloc[-1])
+                if 'BBM_20_2.0' in bollinger_bands.columns and bollinger_bands['BBM_20_2.0'].iloc[-1] is not np.nan: indicators['bb_middle'] = float(bollinger_bands['BBM_20_2.0'].iloc[-1])
         if len(dataframe) >= 14:
             average_true_range = ta.atr(high=dataframe['high'], low=dataframe['low'], close=dataframe['close'], length=14)
-            if average_true_range is not None and not average_true_range.empty and average_true_range.iloc[-1] is not np.nan: 
-                indicators['atr'] = float(average_true_range.iloc[-1])
-                
+            if average_true_range is not None and not average_true_range.empty and average_true_range.iloc[-1] is not np.nan: indicators['atr'] = float(average_true_range.iloc[-1])
         if len(dataframe) >= 26:
             ema_12 = ta.ema(dataframe['close'], length=12)
             ema_26 = ta.ema(dataframe['close'], length=26)
-            if ema_12 is not None and not ema_12.empty and ema_12.iloc[-1] is not np.nan: 
-                indicators['ema_12'] = float(ema_12.iloc[-1])
-            if ema_26 is not None and not ema_26.empty and ema_26.iloc[-1] is not np.nan: 
-                indicators['ema_26'] = float(ema_26.iloc[-1])
-                
+            if ema_12 is not None and not ema_12.empty and ema_12.iloc[-1] is not np.nan: indicators['ema_12'] = float(ema_12.iloc[-1])
+            if ema_26 is not None and not ema_26.empty and ema_26.iloc[-1] is not np.nan: indicators['ema_26'] = float(ema_26.iloc[-1])
         return indicators
 
     def _normalize_features_corrected(self, features):
-        """تطبيع الميزات بشكل صحيح"""
         normalized_features = {}
         for key, value in features.items():
-            if value is None: 
-                normalized_features[key] = 0.0
-                continue
-            if key == 'rsi': 
-                normalized_features[key] = max(0, min(100, value))
-            elif key in ['macd_hist', 'macd_line', 'macd_signal', 'vwap', 'atr']: 
-                normalized_features[key] = value
-            elif 'ema' in key or 'bb_' in key: 
-                normalized_features[key] = value
+            if value is None: normalized_features[key] = 0.0; continue
+            if key == 'rsi': normalized_features[key] = max(0, min(100, value))
+            elif key in ['macd_hist', 'macd_line', 'macd_signal', 'vwap', 'atr']: normalized_features[key] = value
+            elif 'ema' in key or 'bb_' in key: normalized_features[key] = value
             else:
                 try:
-                    if abs(value) > 1000: 
-                        normalized_features[key] = value / 1000
-                    else: 
-                        normalized_features[key] = value
-                except: 
-                    normalized_features[key] = value
+                    if abs(value) > 1000: normalized_features[key] = value / 1000
+                    else: normalized_features[key] = value
+                except: normalized_features[key] = value
         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]
@@ -1108,58 +696,42 @@ class MLProcessor:
             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
+            if (simulated_prices[-1] / initial_price) > 1.02: success_count += 1
         return success_count / number_of_simulations
 
     def _calculate_initial_score(self, indicators, current_price, market_context):
-        """حساب النقاط الأولية"""
         score = 0.5
         fast_timeframes = ['5m', '15m']
         for timeframe in fast_timeframes:
             timeframe_indicators = indicators.get(timeframe, {})
-            if not timeframe_indicators: 
-                continue
+            if not timeframe_indicators: continue
             if 'rsi' in timeframe_indicators:
                 rsi_value = timeframe_indicators['rsi']
                 if isinstance(rsi_value, (int, float)):
-                    if rsi_value < 30: 
-                        score += 0.2
-                    elif rsi_value < 40: 
-                        score += 0.1
-                    elif rsi_value > 70: 
-                        score -= 0.1
-            if 'macd_hist' in timeframe_indicators and timeframe_indicators['macd_hist'] > 0: 
-                score += 0.15
+                    if rsi_value < 30: score += 0.2
+                    elif rsi_value < 40: score += 0.1
+                    elif rsi_value > 70: score -= 0.1
+            if 'macd_hist' in timeframe_indicators and timeframe_indicators['macd_hist'] > 0: score += 0.15
             if all(key in timeframe_indicators for key in ['ema_12', 'ema_26']):
-                if timeframe_indicators['ema_12'] > timeframe_indicators['ema_26']: 
-                    score += 0.15
+                if timeframe_indicators['ema_12'] > timeframe_indicators['ema_26']: score += 0.15
         slow_timeframes = ['1h', '4h', '1d']
         for timeframe in slow_timeframes:
             timeframe_indicators = indicators.get(timeframe, {})
-            if not timeframe_indicators: 
-                continue
+            if not timeframe_indicators: continue
             if all(key in timeframe_indicators for key in ['ema_12', 'ema_26']):
-                if timeframe_indicators['ema_12'] > timeframe_indicators['ema_26']: 
-                    score += 0.10
+                if timeframe_indicators['ema_12'] > timeframe_indicators['ema_26']: score += 0.10
             if all(key in timeframe_indicators for key in ['bb_upper', 'bb_lower']):
-                if current_price > timeframe_indicators['bb_upper']: 
-                    score += 0.10
-                elif current_price <= timeframe_indicators['bb_lower']: 
-                    score += 0.05
-        if '5m' in indicators and 'vwap' in indicators['5m'] and current_price > indicators['5m']['vwap']: 
-            score += 0.10
+                if current_price > timeframe_indicators['bb_upper']: score += 0.10
+                elif current_price <= timeframe_indicators['bb_lower']: score += 0.05
+        if '5m' in indicators and 'vwap' in indicators['5m'] and current_price > indicators['5m']['vwap']: score += 0.10
         if market_context:
             bitcoin_sentiment = market_context.get('btc_sentiment')
             fear_greed_index = market_context.get('fear_and_greed_index', 50)
-            if bitcoin_sentiment == 'BULLISH' and fear_greed_index > 60: 
-                score *= 1.2
-            elif bitcoin_sentiment == 'BEARISH' or fear_greed_index < 30: 
-                score *= 0.8
+            if bitcoin_sentiment == 'BULLISH' and fear_greed_index > 60: score *= 1.2
+            elif bitcoin_sentiment == 'BEARISH' or fear_greed_index < 30: score *= 0.8
         return min(max(score, 0.0), 1.0)
     
-    def _normalize_features(self, features):
-        return self._normalize_features_corrected(features)
+    def _normalize_features(self, features): return self._normalize_features_corrected(features)
 
     def _prepare_data_for_ml(self, all_indicators, current_price):
         feature_vector = []
@@ -1167,236 +739,62 @@ class MLProcessor:
         indicator_keys = ['rsi', 'macd_hist', 'macd_line', 'bb_upper', 'bb_lower', 'atr', 'ema_12', 'ema_26', 'vwap']
         for timeframe in timeframes:
             timeframe_indicators = all_indicators.get(timeframe, {})
-            for key in indicator_keys: 
-                feature_vector.append(timeframe_indicators.get(key, 0.0))
+            for key in indicator_keys: feature_vector.append(timeframe_indicators.get(key, 0.0))
         feature_vector.append(current_price)
         return feature_vector
         
     def _calculate_liquidity_score(self, hourly_dataframe):
-        if hourly_dataframe.empty: 
-            return 0.0
+        if hourly_dataframe.empty: return 0.0
         hourly_dataframe['dollar_volume'] = hourly_dataframe['volume'] * hourly_dataframe['close']
         return float(hourly_dataframe['dollar_volume'].mean())
 
-    def _calculate_fibonacci_levels(self, daily_dataframe):
-        """مهملة: استخدام _improve_fibonacci_levels بدلاً من ذلك"""
-        return self._improve_fibonacci_levels(daily_dataframe, 0)
+    def _calculate_fibonacci_levels(self, daily_dataframe): return self._improve_fibonacci_levels(daily_dataframe, 0)
 
     def classify_opportunity_type(self, indicators, current_price):
-        fast_signals = 0
-        slow_signals = 0
+        fast_signals = slow_signals = 0
         for timeframe in ['5m', '15m']:
             timeframe_indicators = indicators.get(timeframe, {})
-            if not timeframe_indicators: 
-                continue
-            if timeframe_indicators.get('rsi', 100) < 35: 
-                fast_signals += 1
-            if timeframe_indicators.get('macd_hist', 0) > 0: 
-                fast_signals += 1
+            if not timeframe_indicators: continue
+            if timeframe_indicators.get('rsi', 100) < 35: fast_signals += 1
+            if timeframe_indicators.get('macd_hist', 0) > 0: fast_signals += 1
             if all(key in timeframe_indicators for key in ['ema_12', 'ema_26']):
-                if timeframe_indicators['ema_12'] > timeframe_indicators['ema_26']: 
-                    fast_signals += 1
-            if timeframe == '5m' and timeframe_indicators.get('vwap') and current_price > timeframe_indicators['vwap'] * 1.02: 
-                fast_signals += 1
+                if timeframe_indicators['ema_12'] > timeframe_indicators['ema_26']: fast_signals += 1
+            if timeframe == '5m' and timeframe_indicators.get('vwap') and current_price > timeframe_indicators['vwap'] * 1.02: fast_signals += 1
         for timeframe in ['1h', '4h', '1d']:
             timeframe_indicators = indicators.get(timeframe, {})
-            if not timeframe_indicators: 
-                continue
-            if 40 <= timeframe_indicators.get('rsi', 50) <= 60: 
-                slow_signals += 1
+            if not timeframe_indicators: continue
+            if 40 <= timeframe_indicators.get('rsi', 50) <= 60: slow_signals += 1
             if all(key in timeframe_indicators for key in ['ema_12', 'ema_26']):
-                if timeframe_indicators['ema_12'] > timeframe_indicators['ema_26']: 
-                    slow_signals += 1
-            if timeframe_indicators.get('bb_middle') and current_price > timeframe_indicators['bb_middle']: 
-                slow_signals += 1
+                if timeframe_indicators['ema_12'] > timeframe_indicators['ema_26']: slow_signals += 1
+            if timeframe_indicators.get('bb_middle') and current_price > timeframe_indicators['bb_middle']: slow_signals += 1
         if fast_signals >= 3:
             return {
                 "type": "FAST_PUMP", "timeframe": "15m-1h", "take_profit_multiplier": 1.08, "stop_loss_multiplier": 0.97, 
-                "confidence": min(fast_signals / 6.0, 1.0), "description": "فرصة صعود سريع قوية على الأطر الزمنية القصيرة"
+                "confidence": min(fast_signals / 6.0, 1.0), "description": "Strong fast pump opportunity on short timeframes"
             }
         elif slow_signals >= 3:
             return {
                 "type": "SLOW_GROWTH", "timeframe": "4h-1d", "take_profit_multiplier": 1.05, "stop_loss_multiplier": 0.95, 
-                "confidence": min(slow_signals / 6.0, 1.0), "description": "فرصة نمو مستدام على الأطر الزمنية الطويلة"
+                "confidence": min(slow_signals / 6.0, 1.0), "description": "Sustainable growth opportunity on long timeframes"
             }
         return {
             "type": "NEUTRAL", "timeframe": "N/A", "take_profit_multiplier": 1.05, "stop_loss_multiplier": 0.95, 
-            "confidence": 0.3, "description": "لا توجد إشارات واضحة لنوع محدد من الفرص"
+            "confidence": 0.3, "description": "No clear signals for specific opportunity type"
         }
     
     def _calculate_whale_activity_score(self, whale_data):
-        """حساب درجة نشاط الحيتان بناءً على البيانات الحقيقية فقط"""
-        if not whale_data.get('data_available', False):
-            return 0.0
-            
+        if not whale_data.get('data_available', False): return 0.0
         total_transactions = whale_data.get('transfer_count', 0)
         total_volume = whale_data.get('total_volume', 0)
-        
         score = 0.0
-        if total_transactions >= 10:
-            score += 0.3
-        elif total_transactions >= 5:
-            score += 0.15
-            
-        if total_volume > 500000:
-            score += 0.2
-        elif total_volume > 100000:
-            score += 0.1
-            
+        if total_transactions >= 10: score += 0.3
+        elif total_transactions >= 5: score += 0.15
+        if total_volume > 500000: score += 0.2
+        elif total_volume > 100000: score += 0.1
         return min(score, 0.5)
 
     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]
 
-# دوال المحاكاة المحلية للاستخدام كبديل
-def local_analyze_opportunity(candidate_data):
-    """تحليل محسن مع مراعاة مخاطر RSI"""
-    score = candidate_data.get('enhanced_final_score', candidate_data.get('final_score', 0))
-    quality_warnings = candidate_data.get('quality_warnings', [])
-    
-    # التحقق من تحذيرات RSI
-    rsi_critical = any('🚨 RSI CRITICAL' in warning for warning in quality_warnings)
-    rsi_warning = any('⚠️ RSI WARNING' in warning for warning in quality_warnings)
-    
-    if rsi_critical:
-        return {
-            "action": "HOLD", 
-            "reasoning": "Local analysis: CRITICAL RSI levels detected - extreme overbought condition. High risk of correction.",
-            "trade_type": "NONE", 
-            "stop_loss": None, 
-            "take_profit": None, 
-            "expected_target_minutes": 15,
-            "confidence_level": 0.1, 
-            "model_source": "local_safety_filter",
-            "strategy": "GENERIC"
-        }
-    
-    advanced_indicators = candidate_data.get('advanced_indicators', {})
-    strategy_scores = candidate_data.get('strategy_scores', {})
-    
-    if not advanced_indicators:
-        return {
-            "action": "HOLD", 
-            "reasoning": "Local analysis: Insufficient advanced indicator data.",
-            "trade_type": "NONE", 
-            "stop_loss": None, 
-            "take_profit": None, 
-            "expected_target_minutes": 15,
-            "confidence_level": 0.3, 
-            "model_source": "local",
-            "strategy": "GENERIC"
-        }
-    
-    action = "HOLD"
-    reasoning = "Local analysis: No strong buy signal based on enhanced rules."
-    trade_type = "NONE"
-    stop_loss = None
-    take_profit = None
-    expected_minutes = 15
-    confidence = 0.3
-    
-    five_minute_indicators = advanced_indicators.get('5m', {})
-    one_hour_indicators = advanced_indicators.get('1h', {})
-    
-    buy_conditions = 0
-    total_conditions = 0
-    
-    if isinstance(score, (int, float)) and score > 0.70: 
-        buy_conditions += 1
-    total_conditions += 1
-    
-    # شرط RSI أكثر تحفظاً
-    rsi_five_minute = five_minute_indicators.get('rsi', 50)
-    if 30 <= rsi_five_minute <= 65:  # نطاق آمن لـ RSI
-        buy_conditions += 1
-    total_conditions += 1
-    
-    if five_minute_indicators.get('macd_hist', 0) > 0: 
-        buy_conditions += 1
-    total_conditions += 1
-    
-    if (five_minute_indicators.get('ema_9', 0) > five_minute_indicators.get('ema_21', 0) and
-        one_hour_indicators.get('ema_9', 0) > one_hour_indicators.get('ema_21', 0)): 
-        buy_conditions += 1
-    total_conditions += 1
-    
-    if five_minute_indicators.get('volume_ratio', 0) > 1.5: 
-        buy_conditions += 1
-    total_conditions += 1
-    
-    confidence = buy_conditions / total_conditions if total_conditions > 0 else 0.3
-    
-    # خصم الثقة بناءً على تحذيرات RSI
-    if rsi_warning:
-        confidence *= 0.7  # خصم 30% للتحذيرات
-        reasoning += " RSI warning applied."
-    
-    if confidence >= 0.6:
-        action = "BUY"
-        current_price = candidate_data['current_price']
-        trade_type = "LONG"
-        
-        # وقف خسارة أكثر تحفظاً لـ RSI المرتفع
-        if rsi_warning:
-            stop_loss = current_price * 0.93  # 7% stop loss للتحذيرات
-        else:
-            stop_loss = current_price * 0.95  # 5% stop loss عادي
-        
-        if 'bb_upper' in five_minute_indicators:
-            take_profit = five_minute_indicators['bb_upper'] * 1.02
-        else:
-            take_profit = current_price * 1.05
-        
-        if confidence >= 0.8: 
-            expected_minutes = 10
-        elif confidence >= 0.6: 
-            expected_minutes = 18
-        else: 
-            expected_minutes = 25
-        
-        reasoning = f"Local enhanced analysis: Strong buy signal with {buy_conditions}/{total_conditions} conditions met. Confidence: {confidence:.2f}"
-        if rsi_warning:
-            reasoning += " (RSI warning - trading with caution)"
-    
-    return {
-        "action": action,
-        "reasoning": reasoning,
-        "trade_type": trade_type,
-        "stop_loss": stop_loss,
-        "take_profit": take_profit,
-        "expected_target_minutes": expected_minutes,
-        "confidence_level": confidence,
-        "model_source": "local",
-        "strategy": "GENERIC"
-    }
-
-def local_re_analyze_trade(trade_data, processed_data):
-    current_price = processed_data['current_price']
-    stop_loss = trade_data['stop_loss']
-    take_profit = trade_data['take_profit']
-    action = "HOLD"
-    reasoning = "Local re-analysis: No significant change to trigger an update or close."
-    if stop_loss and current_price <= stop_loss: 
-        action = "CLOSE_TRADE"
-        reasoning = "Local re-analysis: Stop loss has been hit."
-    elif take_profit and current_price >= take_profit: 
-        action = "CLOSE_TRADE"
-        reasoning = "Local re-analysis: Take profit has been hit."
-    
-    strategy = trade_data.get('strategy', 'GENERIC')
-    if strategy == 'unknown':
-        strategy = trade_data.get('decision_data', {}).get('strategy', 'GENERIC')
-    
-    return {
-        "action": action,
-        "reasoning": reasoning,
-        "new_stop_loss": None,
-        "new_take_profit": None,
-        "new_expected_minutes": None,
-        "model_source": "local",
-        "strategy": strategy
-    }
-
 print("✅ Enhanced ML System Loaded - Integrated with Learning Engine - REAL DATA ONLY - Optimized Strategy Scoring with Pattern Enhancement")