Create strategies.py

ml_engine/strategies.py

@@ -0,0 +1,334 @@
+# ml_engine/strategies.py
+import asyncio
+
+# الاستيراد من الوحدات الداخلية في نفس المجلد
+from .patterns import ChartPatternAnalyzer
+
+class PatternEnhancedStrategyEngine:
+    def __init__(self, data_manager, learning_engine):
+        self.data_manager = data_manager
+        self.learning_engine = learning_engine
+        self.pattern_analyzer = ChartPatternAnalyzer()
+        
+    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
+            
+        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.6:
+            enhancement_factor = self._calculate_pattern_enhancement(pattern_confidence, pattern_name)
+            enhanced_strategies = self._get_pattern_appropriate_strategies(pattern_name, predicted_direction)
+            
+            print(f"🎯 تعزيز استراتيجيات {symbol} بناءً على نمط {pattern_name} (ثقة: {pattern_confidence:.2f})")
+            
+            for strategy in enhanced_strategies:
+                if strategy in strategy_scores:
+                    original_score = strategy_scores[strategy]
+                    strategy_scores[strategy] = min(original_score * enhancement_factor, 1.0)
+                    print(f"   📈 {strategy}: {original_score:.3f} → {strategy_scores[strategy]:.3f}")
+        
+        return strategy_scores
+    
+    def _calculate_pattern_enhancement(self, pattern_confidence, pattern_name):
+        """حساب عامل التعزيز بناءً على ثقة النمط ونوعه"""
+        base_enhancement = 1.0 + (pattern_confidence * 0.3)
+        high_reliability_patterns = ['Double Top', 'Double Bottom', 'Head & Shoulders', 'Cup and Handle']
+        if pattern_name in high_reliability_patterns: 
+            base_enhancement *= 1.1
+        return min(base_enhancement, 1.5)
+    
+    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']
+
+class MultiStrategyEngine:
+    def __init__(self, data_manager, learning_engine):
+        self.data_manager = data_manager
+        self.learning_engine = learning_engine
+        
+        # 🔴 ملاحظة: تم إزالة مُهيِئات (constructors) التحليل غير المستخدمة من هنا
+        # الاستراتيجيات تستهلك البيانات المحسوبة مسبقاً من (symbol_data)
+        # التي يوفرها (MLProcessor) الرئيسي
+        
+        self.pattern_enhancer = PatternEnhancedStrategyEngine(data_manager, learning_engine)
+        
+        self.strategies = {
+            'trend_following': self._trend_following_strategy,
+            'mean_reversion': self._mean_reversion_strategy,
+            'breakout_momentum': self._breakout_momentum_strategy,
+            'volume_spike': self._volume_spike_strategy,
+            'whale_tracking': self._whale_tracking_strategy,
+            'pattern_recognition': self._pattern_recognition_strategy,
+            'hybrid_ai': self._hybrid_ai_strategy
+        }
+    
+    async def evaluate_all_strategies(self, symbol_data, market_context):
+        """تقييم جميع استراتيجيات التداول"""
+        try:
+            if self.learning_engine and hasattr(self.learning_engine, 'initialized') and self.learning_engine.initialized:
+                try: 
+                    market_condition = market_context.get('market_trend', 'sideways_market')
+                    optimized_weights = await self.learning_engine.get_optimized_strategy_weights(market_condition)
+                except Exception as e: 
+                    # ❌ لا نستخدم قيم افتراضية، نستخدم الأوزان الأساسية
+                    optimized_weights = await self.get_default_weights()
+            else:
+                optimized_weights = await self.get_default_weights()
+                
+            strategy_scores = {}
+            base_scores = {}
+            
+            for strategy_name, strategy_function in self.strategies.items():
+                try: 
+                    base_score = await strategy_function(symbol_data, market_context)
+                    if base_score is None:  # ❌ إذا فشلت الاستراتيجية، لا نستخدم قيم افتراضية
+                        continue
+                    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)
+                except Exception as error:
+                    print(f"❌ خطأ في تقييم استراتيجية {strategy_name}: {error}")
+                    # ❌ لا نستخدم أي محاكاة أو قيم افتراضية
+                    continue
+            
+            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 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
+            
+            return strategy_scores, base_scores
+            
+        except Exception as error:
+            print(f"❌ خطأ في تقييم الاستراتيجيات: {error}")
+            # ❌ لا نستخدم أي محاكاة
+            return {}, {}
+    
+    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
+        }
+    
+    async def _trend_following_strategy(self, symbol_data, market_context):
+        """استراتيجية تتبع الاتجاه"""
+        try:
+            score = 0.0
+            indicators = symbol_data.get('advanced_indicators', {})
+            
+            for timeframe in ['4h', '1h', '15m']:
+                if timeframe in indicators:
+                    timeframe_indicators = indicators[timeframe]
+                    
+                    if self._check_ema_alignment(timeframe_indicators): 
+                        score += 0.20
+                    
+                    adx_value = timeframe_indicators.get('adx', 0)
+                    if adx_value > 25: 
+                        score += 0.15
+                    
+                    if (timeframe_indicators.get('ichimoku_conversion', 0) > 
+                        timeframe_indicators.get('ichimoku_base', 0)):
+                        score += 0.10
+            
+            return min(score, 1.0)
+        except Exception as error:
+            print(f"❌ خطأ في استراتيجية تتبع الاتجاه: {error}")
+            return None  # ❌ لا نرجع قيمة افتراضية
+    
+    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'])
+        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']
+                
+                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
+                    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
+                elif rsi_value > 70: 
+                    score += 0.35
+            
+            return min(score, 1.0)
+        except Exception as error:
+            print(f"❌ خطأ في استراتيجية العودة للمتوسط: {error}")
+            return None  # ❌ لا نرجع قيمة افتراضية
+    
+    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']:
+                if timeframe in indicators:
+                    timeframe_indicators = indicators[timeframe]
+                    
+                    volume_ratio = timeframe_indicators.get('volume_ratio', 0)
+                    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: 
+                        score += 0.10
+            
+            if score > 0.2: 
+                score = max(score, 0.4)
+            
+            return min(score, 1.0)
+        except Exception as error:
+            print(f"❌ خطأ في استراتيجية زخم الاختراق: {error}")
+            return None  # ❌ لا نرجع قيمة افتراضية
+    
+    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
+                    elif volume_ratio > 2.0: 
+                        score += 0.25
+                    elif volume_ratio > 1.5: 
+                        score += 0.15
+            
+            return min(score, 1.0)
+        except Exception as error:
+            print(f"❌ خطأ في استراتيجية ارتفاع الحجم: {error}")
+            return None  # ❌ لا نرجع قيمة افتراضية
+    
+    async def _whale_tracking_strategy(self, symbol_data, market_context):
+        """استراتيجية تتبع الحيتان"""
+        try:
+            whale_data = symbol_data.get('whale_data', {})
+            if not whale_data.get('data_available', False):
+                return None  # ❌ لا نرجع قيمة افتراضية
+            
+            whale_signal = await self.data_manager.get_whale_trading_signal(
+                symbol_data['symbol'], whale_data, market_context
+            )
+            
+            if whale_signal and whale_signal.get('action') != 'HOLD':
+                confidence = whale_signal.get('confidence', 0)
+                if whale_signal.get('action') in ['STRONG_BUY', 'BUY']:
+                    return min(confidence * 1.2, 1.0)
+                elif whale_signal.get('action') in ['STRONG_SELL', 'SELL']:
+                    return min(confidence * 0.8, 1.0)
+            
+            return None  # ❌ لا نرجع قيمة افتراضية
+        except Exception as error: 
+            print(f"❌ خطأ في استراتيجية تتبع الحيتان: {error}")
+            return None  # ❌ لا نرجع قيمة افتراضية
+    
+    async def _pattern_recognition_strategy(self, symbol_data, market_context):
+        """استراتيجية التعرف على الأنماط"""
+        try:
+            score = 0.0
+            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
+            else:
+                indicators = symbol_data.get('advanced_indicators', {})
+                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
+            
+            return min(score, 1.0)
+        except Exception as error:
+            print(f"❌ خطأ في استراتيجية التعرف على الأنماط: {error}")
+            return None  # ❌ لا نرجع قيمة افتراضية
+    
+    async def _hybrid_ai_strategy(self, symbol_data, market_context):
+        """استراتيجية الهجين الذكية"""
+        try:
+            score = 0.0
+            
+            monte_carlo_probability = symbol_data.get('monte_carlo_probability')
+            if monte_carlo_probability is not None:
+                score += monte_carlo_probability * 0.4
+            
+            final_score = symbol_data.get('final_score', 0)
+            if final_score > 0:
+                score += final_score * 0.3
+            
+            if market_context.get('btc_sentiment') == 'BULLISH': 
+                score += 0.15
+            elif market_context.get('btc_sentiment') == 'BEARISH': 
+                score -= 0.08
+            
+            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.15
+                score += pattern_bonus
+            
+            return max(0.0, min(score, 1.0))
+        except Exception as error:
+            print(f"❌ خطأ في استراتيجية الهجين الذكية: {error}")
+            return None  # ❌ لا نرجع قيمة افتراضية
+
+print("✅ ML Module: Strategy Engine loaded")