Delete ml_engine/strategies.py

ml_engine/strategies.py

@@ -1,300 +0,0 @@
-# ml_engine/strategies.py (Updated to use LearningHub for weights)
-import asyncio
-
-# (Import from internal modules)
-from .patterns import ChartPatternAnalyzer
-
-class PatternEnhancedStrategyEngine:
-    # 🔴 --- START OF CHANGE --- 🔴
-    def __init__(self, data_manager, learning_hub): # (Changed from learning_engine)
-        self.data_manager = data_manager
-        self.learning_hub = learning_hub # (Changed from learning_engine)
-        self.pattern_analyzer = ChartPatternAnalyzer()
-    # 🔴 --- END OF CHANGE --- 🔴
-        
-    async def enhance_strategy_with_patterns(self, strategy_scores, pattern_analysis, symbol):
-        """(Unchanged logic)"""
-        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)
-            
-            # (Omitted print statements for brevity)
-            
-            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)
-        
-        return strategy_scores
-    
-    def _calculate_pattern_enhancement(self, pattern_confidence, pattern_name):
-        """(Unchanged logic)"""
-        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):
-        """(Unchanged logic)"""
-        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:
-    # 🔴 --- START OF CHANGE --- 🔴
-    def __init__(self, data_manager, learning_hub): # (Changed from learning_engine)
-        self.data_manager = data_manager
-        self.learning_hub = learning_hub # (Changed from learning_engine)
-        
-        # (Pass the hub to the enhancer)
-        self.pattern_enhancer = PatternEnhancedStrategyEngine(data_manager, learning_hub)
-    # 🔴 --- END OF CHANGE --- 🔴
-        
-        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):
-        """Evaluate all trading strategies"""
-        try:
-            # 🔴 --- START OF CHANGE --- 🔴
-            # (Get weights from the new Learning Hub)
-            if self.learning_hub and self.learning_hub.initialized:
-                try: 
-                    market_condition = market_context.get('market_trend', 'sideways_market')
-                    # (Call the new hub function)
-                    optimized_weights = await self.learning_hub.get_optimized_weights(market_condition)
-                except Exception as e: 
-                    print(f"⚠️ Error getting optimized weights from hub: {e}. Using defaults.")
-                    optimized_weights = await self.get_default_weights()
-            else:
-                optimized_weights = await self.get_default_weights()
-            # 🔴 --- END OF CHANGE --- 🔴
-                
-            strategy_scores = {}
-            base_scores = {}
-            
-            primary_strategies = [s for s in self.strategies.keys() if s != 'hybrid_ai']
-            
-            for strategy_name in primary_strategies:
-                strategy_function = self.strategies[strategy_name]
-                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"❌ Error evaluating strategy {strategy_name}: {error}")
-                    continue
-            
-            try:
-                hybrid_score = await self._hybrid_ai_strategy(symbol_data, market_context, base_scores)
-                if hybrid_score is not None:
-                    base_scores['hybrid_ai'] = hybrid_score
-                    weight = optimized_weights.get('hybrid_ai', 0.1)
-                    strategy_scores['hybrid_ai'] = min(hybrid_score * weight, 1.0)
-            except Exception as e:
-                print(f"❌ Error in hybrid_ai strategy: {e}")
-
-            # Pattern enhancement (Unchanged)
-            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 in evaluate_all_strategies: {error}")
-            return {}, {}
-    
-    async def get_default_weights(self):
-        """(Unchanged) Default weights"""
-        return {
-            'trend_following': 0.15, 
-            'mean_reversion': 0.12,
-            'breakout_momentum': 0.20,
-            'volume_spike': 0.13,
-            'whale_tracking': 0.20, 
-            'pattern_recognition': 0.10,
-            'hybrid_ai': 0.10
-        }
-    
-    #
-    # (All individual strategy functions remain unchanged)
-    # (_trend_following_strategy, _mean_reversion_strategy, etc.)
-    # (Omitted for brevity)
-    #
-    async def _trend_following_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:
-                    tf_indicators = indicators[timeframe]
-                    ema_21 = tf_indicators.get('ema_21')
-                    ema_50 = tf_indicators.get('ema_50')
-                    adx = tf_indicators.get('adx', 0)
-                    if ema_21 is not None and ema_50 is not None:
-                        if ema_21 > ema_50:
-                            score += 0.2
-                            if adx > 20:
-                                score += 0.1
-                            if symbol_data['current_price'] > ema_21:
-                                score += 0.05
-            return min(score, 1.0)
-        except Exception: 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', {})
-            for timeframe in ['1h', '15m']:
-                if timeframe in indicators:
-                    tf_indicators = indicators[timeframe]
-                    rsi_value = tf_indicators.get('rsi', 50)
-                    bb_lower = tf_indicators.get('bb_lower')
-                    bb_upper = tf_indicators.get('bb_upper')
-                    if bb_lower is None or bb_upper is None: continue
-                    position_in_band = 0.5
-                    if (bb_upper - bb_lower) > 0:
-                        position_in_band = (current_price - bb_lower) / (bb_upper - bb_lower)
-                    is_rsi_oversold = rsi_value < 25
-                    is_bb_oversold = position_in_band < 0.1
-                    if is_rsi_oversold or is_bb_oversold:
-                        score += 0.4
-                        if is_rsi_oversold and is_bb_oversold:
-                            score += 0.2
-            return min(score, 1.0)
-        except Exception: return None
-    
-    async def _breakout_momentum_strategy(self, symbol_data, market_context):
-        try:
-            score = 0.0
-            current_price = symbol_data['current_price']
-            indicators = symbol_data.get('advanced_indicators', {})
-            for timeframe in ['1h', '15m', '5m']:
-                if timeframe in indicators:
-                    tf_indicators = indicators[timeframe]
-                    volume_ratio = tf_indicators.get('volume_ratio', 0)
-                    if volume_ratio < 1.5: continue
-                    score += 0.2
-                    macd_hist = tf_indicators.get('macd_hist', 0)
-                    if macd_hist > 0:
-                        score += 0.1
-                    atr_percent = tf_indicators.get('atr_percent', 0)
-                    if atr_percent > 1.5:
-                        score += 0.1
-                    vwap = tf_indicators.get('vwap')
-                    if vwap and current_price > vwap:
-                        score += 0.05
-            return min(score, 1.0)
-        except Exception: 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: 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)
-            return None
-        except Exception: 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:
-                if pattern_analysis.get('predicted_direction') == 'up':
-                    score += pattern_analysis.get('pattern_confidence', 0) * 0.8
-            else:
-                indicators = symbol_data.get('advanced_indicators', {})
-                if '1h' in indicators:
-                    tf_indicators = indicators['1h']
-                    if (tf_indicators.get('rsi', 50) > 60 and 
-                        tf_indicators.get('macd_hist', 0) > 0): 
-                        score += 0.3
-            return min(score, 1.0)
-        except Exception: return None
-    
-    async def _hybrid_ai_strategy(self, symbol_data, market_context, base_scores):
-        try:
-            score = 0.0
-            monte_carlo_prob = symbol_data.get('monte_carlo_probability')
-            if monte_carlo_prob is not None:
-                score += monte_carlo_prob * 0.4
-            
-            breakout_score = base_scores.get('breakout_momentum', 0)
-            volume_score = base_scores.get('volume_spike', 0)
-            whale_score = base_scores.get('whale_tracking', 0)
-            pattern_score = base_scores.get('pattern_recognition', 0)
-            
-            if breakout_score > 0.7 and volume_score > 0.6: score += 0.3
-            if breakout_score > 0.6 and whale_score > 0.7: score += 0.4
-            if pattern_score > 0.7 and volume_score > 0.5: score += 0.2
-            if breakout_score > 0.7 and whale_score > 0.7 and volume_score > 0.7:
-                score = 1.0
-            return max(0.0, min(score, 1.0))
-        except Exception: return None
-
-print("✅ ML Module: Strategy Engine loaded (V3 - Integrated LearningHub for weights)")