Upload 6 files

LLM (31).py

@@ -0,0 +1,1051 @@
+import os, traceback, asyncio, json, re, ast
+from datetime import datetime, timedelta
+from functools import wraps
+from backoff import on_exception, expo
+from openai import OpenAI, RateLimitError, APITimeoutError, APIStatusError
+import numpy as np, httpx, pandas as pd
+from gnews import GNews
+import feedparser
+
+NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY")
+PRIMARY_MODEL = "nvidia/llama-3.1-nemotron-ultra-253b-v1"
+NVIDIA_RATE_LIMIT_CALLS = 20
+NVIDIA_RATE_LIMIT_PERIOD = 60
+
+CRYPTO_RSS_FEEDS = {
+    "Cointelegraph": "https://cointelegraph.com/rss",
+    "CoinDesk": "https://www.coindesk.com/arc/outboundfeeds/rss/",
+    "CryptoSlate": "https://cryptoslate.com/feed/",
+    "NewsBTC": "https://www.newsbtc.com/feed/",
+    "Bitcoin.com": "https://news.bitcoin.com/feed/"
+}
+
+class NewsFetcher:
+    def __init__(self):
+        self.http_client = httpx.AsyncClient(
+            timeout=10.0, follow_redirects=True,
+            headers={
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                'Accept': 'application/json, text/plain, */*',
+                'Accept-Language': 'en-US,en;q=0.9',
+                'Cache-Control': 'no-cache'
+            }
+        )
+        self.gnews = GNews(language='en', country='US', period='3h', max_results=8)
+
+    async def _fetch_from_gnews(self, symbol: str) -> list:
+        try:
+            base_symbol = symbol.split("/")[0]
+            query = f'"{base_symbol}" cryptocurrency -bitcoin -ethereum -BTC -ETH'
+            print(f"📰 Fetching specific news from GNews for {base_symbol}...")
+            news_items = await asyncio.to_thread(self.gnews.get_news, query)
+            print(f"✅ GNews fetched {len(news_items)} specific items for {base_symbol}.")
+            return news_items
+        except Exception as e:
+            print(f"❌ Failed to fetch specific news from GNews for {symbol}: {e}")
+            return []
+
+    async def _fetch_from_rss_feed(self, feed_url: str, source_name: str, symbol: str) -> list:
+        try:
+            base_symbol = symbol.split('/')[0]
+            print(f"📰 Fetching specific news from {source_name} RSS for {base_symbol}...")
+            max_redirects = 2
+            current_url = feed_url
+            for attempt in range(max_redirects):
+                try:
+                    response = await self.http_client.get(current_url)
+                    response.raise_for_status()
+                    break
+                except httpx.HTTPStatusError as e:
+                    if e.response.status_code in [301, 302, 307, 308] and 'Location' in e.response.headers:
+                        current_url = e.response.headers['Location']
+                        print(f"🔄 Following redirect to: {current_url}")
+                        continue
+                    else: 
+                        raise
+            feed = feedparser.parse(response.text)
+            news_items = []
+            search_term = base_symbol.lower()
+            for entry in feed.entries[:15]:
+                title = entry.title.lower() if hasattr(entry, 'title') else ''
+                summary = entry.summary.lower() if hasattr(entry, 'summary') else entry.description.lower() if hasattr(entry, 'description') else ''
+                if search_term in title or search_term in summary:
+                    news_items.append({
+                        'title': entry.title, 
+                        'description': summary, 
+                        'source': source_name,
+                        'published': entry.get('published', '')
+                    })
+            print(f"✅ {source_name} RSS fetched {len(news_items)} specific items for {base_symbol}.")
+            return news_items
+        except Exception as e:
+            print(f"❌ Failed to fetch specific news from {source_name} RSS for {symbol}: {e}")
+            return []
+            
+    async def get_news_for_symbol(self, symbol: str) -> str:
+        base_symbol = symbol.split("/")[0]
+        tasks = [self._fetch_from_gnews(symbol)]
+        for name, url in CRYPTO_RSS_FEEDS.items():
+            tasks.append(self._fetch_from_rss_feed(url, name, symbol))
+        
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        all_news_text = []
+        
+        for result in results:
+            if isinstance(result, Exception):
+                print(f"⚠️ A news source failed with error: {result}")
+                continue
+            for item in result:
+                if self._is_directly_relevant_to_symbol(item, base_symbol):
+                    title = item.get('title', 'No Title')
+                    description = item.get('description', 'No Description')
+                    source = item.get('source', 'Unknown Source')
+                    published = item.get('published', '')
+                    
+                    news_entry = f"[{source}] {title}. {description}"
+                    if published:
+                        news_entry += f" (Published: {published})"
+                    
+                    all_news_text.append(news_entry)
+        
+        if not all_news_text: 
+            return f"📰 No specific news found for {base_symbol} in the last 3 hours."
+        
+        important_news = all_news_text[:5]
+        return " | ".join(important_news)
+
+    def _is_directly_relevant_to_symbol(self, news_item, base_symbol):
+        title = news_item.get('title', '').lower()
+        description = news_item.get('description', '').lower()
+        symbol_lower = base_symbol.lower()
+        
+        if symbol_lower not in title and symbol_lower not in description:
+            return False
+        
+        crypto_keywords = [
+            'crypto', 'cryptocurrency', 'token', 'blockchain', 
+            'price', 'market', 'trading', 'exchange', 'defi',
+            'coin', 'digital currency', 'altcoin'
+        ]
+        
+        return any(keyword in title or keyword in description for keyword in crypto_keywords)
+
+class PatternAnalysisEngine:
+    def __init__(self, llm_service):
+        self.llm = llm_service
+        self.pattern_templates = {
+            'reversal': ['head_shoulders', 'double_top', 'triple_top', 'rising_wedge', 'falling_wedge'],
+            'continuation': ['flags', 'pennants', 'triangles', 'rectangles', 'cup_and_handle'],
+            'consolidation': ['symmetrical_triangle', 'ascending_triangle', 'descending_triangle']
+        }
+    
+    def _format_chart_data_for_llm(self, ohlcv_data):
+        """تنسيق بيانات الشموع بشكل محسن للنموذج"""
+        if not ohlcv_data or len(ohlcv_data) < 20:
+            return "❌ Insufficient chart data for pattern analysis (minimum 20 candles required)"
+            
+        try:
+            # استخدام آخر 50 شمعة للتحليل الدقيق
+            candles_to_analyze = ohlcv_data[-50:] if len(ohlcv_data) > 50 else ohlcv_data
+            
+            chart_description = [
+                "📊 **CANDLE DATA FOR PATTERN ANALYSIS:**",
+                f"Total candles available: {len(ohlcv_data)}",
+                f"Candles used for analysis: {len(candles_to_analyze)}",
+                ""
+            ]
+            
+            # إضافة معلومات عن الشموع الرئيسية
+            if len(candles_to_analyze) >= 10:
+                recent_candles = candles_to_analyze[-10:]
+                chart_description.append("**Recent 10 Candles (Latest First):**")
+                for i, candle in enumerate(reversed(recent_candles)):
+                    candle_idx = len(candles_to_analyze) - i
+                    desc = f"Candle {candle_idx}: O:{candle[1]:.6f} H:{candle[2]:.6f} L:{candle[3]:.6f} C:{candle[4]:.6f} V:{candle[5]:.0f}"
+                    chart_description.append(f"  {desc}")
+            
+            # تحليل الاتجاه العام
+            if len(candles_to_analyze) >= 2:
+                first_close = candles_to_analyze[0][4]
+                last_close = candles_to_analyze[-1][4]
+                price_change = ((last_close - first_close) / first_close) * 100
+                trend = "📈 BULLISH" if price_change > 2 else "📉 BEARISH" if price_change < -2 else "➡️ SIDEWAYS"
+                
+                # حساب أعلى وأقل سعر
+                highs = [c[2] for c in candles_to_analyze]
+                lows = [c[3] for c in candles_to_analyze]
+                high_max = max(highs)
+                low_min = min(lows)
+                volatility = ((high_max - low_min) / low_min) * 100
+                
+                chart_description.extend([
+                    "",
+                    "**MARKET STRUCTURE ANALYSIS:**",
+                    f"Trend Direction: {trend}",
+                    f"Price Change: {price_change:+.2f}%",
+                    f"Volatility Range: {volatility:.2f}%",
+                    f"Highest Price: {high_max:.6f}",
+                    f"Lowest Price: {low_min:.6f}"
+                ])
+            
+            # تحليل حجم التداول
+            if len(candles_to_analyze) >= 5:
+                volumes = [c[5] for c in candles_to_analyze]
+                avg_volume = sum(volumes) / len(volumes)
+                current_volume = candles_to_analyze[-1][5]
+                volume_ratio = current_volume / avg_volume if avg_volume > 0 else 1
+                
+                volume_signal = "🚀 HIGH" if volume_ratio > 2 else "📊 NORMAL" if volume_ratio > 0.5 else "📉 LOW"
+                chart_description.extend([
+                    "",
+                    "**VOLUME ANALYSIS:**",
+                    f"Current Volume: {current_volume:,.0f}",
+                    f"Volume Ratio: {volume_ratio:.2f}x average",
+                    f"Volume Signal: {volume_signal}"
+                ])
+            
+            return "\n".join(chart_description)
+            
+        except Exception as e:
+            return f"❌ Error formatting chart data: {str(e)}"
+    
+    async def analyze_chart_patterns(self, symbol, ohlcv_data):
+        """تحليل الأنماط البيانية مع تحسينات كبيرة"""
+        try:
+            if not ohlcv_data or len(ohlcv_data) < 20:
+                return {
+                    "pattern_detected": "insufficient_data",
+                    "pattern_confidence": 0.1,
+                    "pattern_strength": "weak",
+                    "predicted_direction": "unknown",
+                    "pattern_analysis": "Insufficient candle data for pattern analysis"
+                }
+            
+            chart_text = self._format_chart_data_for_llm(ohlcv_data)
+            
+            prompt = f"""
+            🔍 **CRYPTO CHART PATTERN ANALYSIS REQUEST**
+            
+            You are an expert cryptocurrency technical analyst with 10+ years experience. 
+            Analyze the following candle data for {symbol} and identify STRONG, ACTIONABLE patterns.
+
+            **ANALYSIS REQUIREMENTS:**
+            1. Focus on CLEAR, HIGH-PROBABILITY patterns only
+            2. Consider volume confirmation for all patterns
+            3. Evaluate pattern strength based on candle formations
+            4. Provide SPECIFIC price targets and stop levels
+            5. Assess timeframe suitability for 5-45 minute trades
+
+            **CANDLE DATA FOR ANALYSIS:**
+            {chart_text}
+
+            **PATTERNS TO LOOK FOR:**
+            🎯 REVERSAL PATTERNS: Head & Shoulders, Double Top/Bottom, Triple Top/Bottom
+            🎯 CONTINUATION PATTERNS: Flags, Pennants, Triangles, Rectangles  
+            🎯 CONSOLIDATION PATTERNS: Symmetrical/Descending/Ascending Triangles
+            🎯 SUPPORT/RESISTANCE: Key levels from recent highs/lows
+
+            **MANDATORY OUTPUT FORMAT (JSON):**
+            {{
+                "pattern_detected": "pattern_name",
+                "pattern_confidence": 0.85,
+                "pattern_strength": "strong/medium/weak",
+                "predicted_direction": "up/down/sideways",
+                "predicted_movement_percent": 5.50,
+                "timeframe_expectation": "15-25 minutes",
+                "entry_suggestion": 0.1234,
+                "target_suggestion": 0.1357,
+                "stop_suggestion": 0.1189,
+                "key_support": 0.1200,
+                "key_resistance": 0.1300,
+                "pattern_analysis": "Detailed explanation of the pattern, why it's valid, and volume confirmation"
+            }}
+
+            **CRITICAL:**
+            - Only identify patterns if you have ≥ 70% confidence
+            - MUST consider volume in pattern confirmation
+            - Provide SPECIFIC numbers for entry/target/stop
+            - If no clear pattern, set pattern_detected to "no_clear_pattern"
+            """
+            
+            print(f"🔍 Analyzing chart patterns for {symbol} with {len(ohlcv_data)} candles...")
+            response = await self.llm._call_llm(prompt)
+            
+            pattern_result = self._parse_pattern_response(response)
+            if pattern_result and pattern_result.get('pattern_detected') != 'no_clear_pattern':
+                print(f"✅ Pattern detected for {symbol}: {pattern_result.get('pattern_detected')} "
+                      f"(Confidence: {pattern_result.get('pattern_confidence', 0):.2f})")
+            else:
+                print(f"ℹ️ No clear patterns for {symbol}")
+                
+            return pattern_result
+            
+        except Exception as e:
+            print(f"❌ Chart pattern analysis failed for {symbol}: {e}")
+            return None
+
+    def _parse_pattern_response(self, response_text):
+        """تحليل رد النموذج مع تحسينات التعامل مع الأخطاء"""
+        try:
+            # البحث عن JSON في الرد
+            json_match = re.search(r'\{.*\}', response_text, re.DOTALL)
+            if not json_match:
+                return {
+                    "pattern_detected": "parse_error",
+                    "pattern_confidence": 0.1,
+                    "pattern_analysis": "Could not parse pattern analysis response"
+                }
+            
+            pattern_data = json.loads(json_match.group())
+            
+            # التحقق من الحقول الأساسية
+            required = ['pattern_detected', 'pattern_confidence', 'predicted_direction']
+            if not all(field in pattern_data for field in required):
+                return {
+                    "pattern_detected": "incomplete_data",
+                    "pattern_confidence": 0.1,
+                    "pattern_analysis": "Incomplete pattern analysis data"
+                }
+            
+            return pattern_data
+            
+        except Exception as e:
+            print(f"❌ Error parsing pattern response: {e}")
+            return {
+                "pattern_detected": "parse_error",
+                "pattern_confidence": 0.1,
+                "pattern_analysis": f"Error parsing pattern analysis: {str(e)}"
+            }
+
+class LLMService:
+    def __init__(self, api_key=NVIDIA_API_KEY, model_name=PRIMARY_MODEL, temperature=0.7):
+        self.api_key = api_key
+        self.model_name = model_name
+        self.temperature = temperature
+        self.client = OpenAI(base_url="https://integrate.api.nvidia.com/v1", api_key=self.api_key)
+        self.news_fetcher = NewsFetcher()
+        self.pattern_engine = PatternAnalysisEngine(self)
+        self.semaphore = asyncio.Semaphore(5)
+
+    def _rate_limit_nvidia_api(func):
+        @wraps(func)
+        @on_exception(expo, RateLimitError, max_tries=5)
+        async def wrapper(*args, **kwargs):
+            return await func(*args, **kwargs)
+        return wrapper
+
+    async def get_trading_decision(self, data_payload: dict):
+        try:
+            symbol = data_payload.get('symbol', 'unknown')
+            target_strategy = data_payload.get('target_strategy', 'GENERIC')
+            print(f"🧠 Starting LLM analysis for {symbol} with strategy: {target_strategy}...")
+            
+            news_text = await self.news_fetcher.get_news_for_symbol(symbol)
+            pattern_analysis = await self._get_pattern_analysis(data_payload)
+            prompt = self._create_enhanced_trading_prompt(data_payload, news_text, pattern_analysis)
+            
+            print(f"🧠 Sending enhanced prompt to LLM for {symbol}...")
+            async with self.semaphore:
+                response = await self._call_llm(prompt)
+            
+            decision_dict = self._parse_llm_response_enhanced(response, target_strategy, symbol)
+            if decision_dict:
+                decision_dict['model_source'] = self.model_name
+                decision_dict['pattern_analysis'] = pattern_analysis
+                
+                # ✅ التحقق النهائي من الاستراتيجية
+                final_strategy = decision_dict.get('strategy')
+                if not final_strategy or final_strategy == 'unknown' or final_strategy is None:
+                    decision_dict['strategy'] = target_strategy
+                    print(f"🔧 Final strategy correction for {symbol}: {target_strategy}")
+                else:
+                    print(f"✅ LLM successfully selected strategy '{final_strategy}' for {symbol}.")
+                    
+                print(f"✅ LLM analysis completed for {symbol} - Strategy: {decision_dict['strategy']}")
+            else:
+                print(f"❌ LLM analysis failed for {symbol}")
+                return local_analyze_opportunity(data_payload)
+            
+            return decision_dict
+            
+        except Exception as e:
+            print(f"❌ An error occurred while getting LLM decision for {data_payload.get('symbol', 'unknown')}: {e}")
+            traceback.print_exc()
+            return local_analyze_opportunity(data_payload)
+    
+    def _parse_llm_response_enhanced(self, response_text: str, fallback_strategy: str = 'GENERIC', symbol: str = 'unknown') -> dict:
+        """✅ الإصلاح النهائي: تحليل رد الـ LLM مع إعطاء الثقة لقراره"""
+        try:
+            json_match = re.search(r'```json\n(.*?)\n```', response_text, re.DOTALL)
+            if json_match:
+                json_str = json_match.group(1).strip()
+            else:
+                json_match = re.search(r'\{.*\}', response_text, re.DOTALL)
+                if json_match:
+                    json_str = json_match.group()
+                else:
+                    print(f"❌ No JSON found in LLM response for {symbol}: {response_text}")
+                    return None
+
+            decision_data = json.loads(json_str)
+
+            required_fields = ['action', 'reasoning', 'risk_assessment', 'trade_type',
+                             'stop_loss', 'take_profit', 'expected_target_minutes', 'confidence_level']
+
+            for field in required_fields:
+                if field not in decision_data:
+                    print(f"❌ Missing required field '{field}' in LLM response for {symbol}")
+                    return None
+
+            strategy_value = decision_data.get('strategy')
+            # 💡 التحقق: هل الاستراتيجية التي أرجعها النموذج صالحة؟
+            if not strategy_value or strategy_value == 'unknown' or strategy_value is None:
+                # إذا كانت غير صالحة، استخدم الاستراتيجية العامة كخطة بديلة آمنة
+                print(f"⚠️ LLM returned invalid strategy '{strategy_value}' for {symbol}. Forcing fallback: {fallback_strategy}")
+                decision_data['strategy'] = fallback_strategy
+            else:
+                # إذا كانت صالحة، اعتمدها مباشرةً!
+                print(f"✅ LLM successfully selected strategy '{strategy_value}' for {symbol}.")
+
+            return decision_data
+
+        except Exception as e:
+            print(f"❌ Unexpected error parsing LLM response for {symbol}: {e}")
+            return None
+
+    async def _get_pattern_analysis(self, data_payload):
+        try:
+            symbol = data_payload['symbol']
+            # ✅ الحصول على بيانات الشموع الخام من البيانات المعالجة
+            if 'raw_ohlcv' in data_payload and '1h' in data_payload['raw_ohlcv']:
+                ohlcv_data = data_payload['raw_ohlcv']['1h']
+                if ohlcv_data and len(ohlcv_data) >= 20:
+                    print(f"🔍 Using raw OHLCV data for pattern analysis: {len(ohlcv_data)} candles")
+                    return await self.pattern_engine.analyze_chart_patterns(symbol, ohlcv_data)
+            
+            # ✅ الحصول على بيانات OHLCV من 'advanced_indicators' كبديل
+            if 'advanced_indicators' in data_payload and '1h' in data_payload['advanced_indicators']:
+                ohlcv_data = data_payload['advanced_indicators']['1h']
+                if ohlcv_data and len(ohlcv_data) >= 20:
+                    print(f"🔍 Using advanced indicators data for pattern analysis: {len(ohlcv_data)} candles")
+                    return await self.pattern_engine.analyze_chart_patterns(symbol, ohlcv_data)
+            
+            print(f"⚠️ No sufficient OHLCV data for pattern analysis on {symbol}")
+            return None
+        except Exception as e:
+            print(f"⚠️ Pattern analysis failed for {data_payload.get('symbol')}: {e}")
+            return None
+    
+    def _create_enhanced_trading_prompt(self, payload: dict, news_text: str, pattern_analysis: dict) -> str:
+        symbol = payload.get('symbol', 'N/A')
+        current_price = payload.get('current_price', 'N/A')
+        reasons = payload.get('reasons_for_candidacy', [])
+        sentiment_data = payload.get('sentiment_data', {})
+        advanced_indicators = payload.get('advanced_indicators', {})
+        strategy_scores = payload.get('strategy_scores', {})
+        recommended_strategy = payload.get('recommended_strategy', 'N/A')
+        target_strategy = payload.get('target_strategy', 'GENERIC')
+        final_score = payload.get('final_score', 'N/A')
+        enhanced_final_score = payload.get('enhanced_final_score', 'N/A')
+        whale_data = payload.get('whale_data', {})
+        
+        general_whale_activity = sentiment_data.get('general_whale_activity', {})
+        
+        final_score_display = f"{final_score:.2f}" if isinstance(final_score, (int, float)) else str(final_score)
+        enhanced_score_display = f"{enhanced_final_score:.2f}" if isinstance(enhanced_final_score, (int, float)) else str(enhanced_final_score)
+
+        indicators_summary = self._format_advanced_indicators(advanced_indicators)
+        strategies_summary = self._format_strategies_analysis(strategy_scores, recommended_strategy)
+        pattern_summary = self._format_pattern_analysis_enhanced(pattern_analysis, payload)
+        whale_analysis_section = self._format_whale_analysis_for_llm(general_whale_activity, whale_data, symbol)
+
+        strategy_instructions = {
+            "AGGRESSIVE_GROWTH": "**Strategy: AGGRESSIVE_GROWTH**: Focus on strong price movements (5-10%) and accept higher risk for higher rewards. Aim for 8-15% on successful trades.",
+            "DEFENSIVE_GROWTH": "**Strategy: DEFENSIVE_GROWTH**: Look for safer 3-6% moves with tight stop-losses. Aim for 4-8% while protecting capital.",
+            "CONSERVATIVE": "**Strategy: CONSERVATIVE**: Focus on only 2-4% moves with wider stop-losses. Aim for 2-5% with minimal risk.",
+            "HIGH_FREQUENCY": "**Strategy: HIGH_FREQUENCY**: Look for quick 1-3% scalps with very tight stop-losses. Aim for 1-4% on multiple trades.",
+            "WHALE_FOLLOWING": "**Strategy: WHALE_FOLLOWING**: Prioritize whale tracking signals and unusual volume. Aim for 5-12% with medium risk.",
+            "GENERIC": "**Strategy: GENERIC**: Make balanced decisions considering risk and reward across all factors."
+        }
+        strategy_instruction = strategy_instructions.get(target_strategy, strategy_instructions["GENERIC"])
+
+        data_availability_section = self._format_data_availability(sentiment_data, whale_data, news_text, pattern_analysis)
+
+        prompt = f"""
+        🎯 **ENHANCED TRADING ANALYSIS WITH CHART PATTERNS**
+
+        **ACTIVE STRATEGY: {target_strategy}**
+        {strategy_instruction}
+
+        **CRITICAL CHART PATTERN ANALYSIS:**
+        {pattern_summary}
+
+        **STRATEGIC TIMEFRAME:**
+        - Max trade duration: 45 minutes (will be automatically enforced).
+        - Optimal range: 8-25 minutes for ideal capital rotation.
+        - Minimum duration: 5 minutes for active monitoring.
+
+        {data_availability_section}
+
+        **AVAILABLE DATA FOR {symbol}:**
+
+        **1. 🎯 CANDIDACY REASON:**
+        - This symbol was selected for: {reasons}
+
+        **2. 📊 OVERVIEW:**
+        - Symbol: {symbol}
+        - Current Price: {current_price} USDT
+        - Initial System Score: {final_score_display}
+        - Enhanced System Score: {enhanced_score_display}
+        - Recommended Internal Strategy: {recommended_strategy}
+        - **Target Trading Strategy: {target_strategy}**
+
+        **3. 🎪 STRATEGY ANALYSIS (INTERNAL SCORES):**
+        {strategies_summary}
+
+        **4. 📈 ADVANCED TECHNICAL INDICATORS:**
+        {indicators_summary}
+
+        **5. 🌍 COMPREHENSIVE MARKET CONTEXT:**
+        - BTC Trend: {sentiment_data.get('btc_sentiment', 'N/A')}
+        - Fear & Greed Index: {sentiment_data.get('fear_and_greed_index', 'N/A')} ({sentiment_data.get('sentiment_class', 'N/A')})
+        - Market Regime: {sentiment_data.get('market_trend', 'N/A')}
+
+        **6. 🐋 ADVANCED WHALE ANALYSIS:**
+        {whale_analysis_section}
+
+        **7. 📰 RECENT NEWS (LAST 3 HOURS):**
+        {news_text}
+
+        **YOUR MISSION:**
+        Integrate the chart pattern analysis above with all other available data to make a FINAL trading decision.
+
+        **IF PATTERN ANALYSIS SHOWS STRONG SIGNALS:**
+        - Give it significant weight in your decision
+        - Use the pattern's entry/target/stop suggestions
+        - Consider the pattern's confidence level
+
+        **IF NO CLEAR PATTERNS:**
+        - Rely more on technical indicators and market context
+        - Be more conservative with targets and stops
+
+        **REQUIRED OUTPUTS (JSON ONLY):**
+        - `action`: Must be one of ("BUY", "SELL", "HOLD")
+        - `reasoning`: Detailed explanation focusing on {target_strategy} AND SPECIFICALLY MENTIONING chart pattern analysis
+        - `risk_assessment`: Risk analysis aligned with {target_strategy} and available data
+        - `trade_type`: ("LONG" for BUY, "SHORT" for SELL)
+        - `stop_loss`: Stop loss price (consider {target_strategy} risk profile AND pattern suggestions)
+        - `take_profit`: Take profit price (realistic for {target_strategy} AND pattern targets)
+        - `expected_target_minutes`: Realistic expectation (5-45 minutes)
+        - `confidence_level`: Your confidence level (0.00-1.00) based on data quality AND pattern confidence
+        - `strategy`: "{target_strategy}"  # ⚠️ MUST BE EXACTLY: {target_strategy}
+        - `pattern_influence`: "Describe how chart pattern affected decision"
+
+        **CRITICAL: You MUST include the 'strategy' field with the exact value: "{target_strategy}"**
+
+        **SPECIAL INSTRUCTIONS FOR PATTERN INTEGRATION:**
+        - If pattern_confidence > 0.7, you MUST reference it prominently in reasoning
+        - If pattern suggests specific levels, strongly consider using them
+        - Always explain how patterns influenced your final decision in 'pattern_influence'
+
+        **Example output format (JSON only):**
+        ```json
+        {{
+            "action": "BUY",
+            "reasoning": "Strong bullish signals aligned with {target_strategy}. High-confidence Double Top pattern detected with 85% confidence suggesting upward movement. Whale activity is positive. Limited news data, but technicals and pattern are strong.",
+            "risk_assessment": "Moderate risk suitable for {target_strategy}. Pattern provides clear stop and target levels. Note: Some data sources unavailable.",
+            "trade_type": "LONG",
+            "stop_loss": 0.0285,
+            "take_profit": 0.0320,
+            "expected_target_minutes": 12,
+            "confidence_level": 0.82,
+            "strategy": "{target_strategy}",
+            "pattern_influence": "Double Top pattern provided clear entry and target levels, increasing confidence in the trade setup."
+        }}
+        ```
+        """
+        return prompt
+
+    def _format_data_availability(self, sentiment_data, whale_data, news_text, pattern_analysis):
+        general_whale_available = sentiment_data.get('general_whale_activity', {}).get('data_available', False)
+        symbol_whale_available = whale_data.get('data_available', False)
+        news_available = "No specific news found" not in news_text
+        pattern_available = pattern_analysis is not None and pattern_analysis.get('pattern_detected') != 'no_clear_pattern'
+        
+        return f"""
+**📊 REAL DATA AVAILABILITY STATUS:**
+- Market Sentiment: {'✅ Available' if sentiment_data.get('fear_and_greed_index') else '❌ Not Available'}
+- General Whale Activity: {'✅ Available' if general_whale_available else '❌ Not Available'}
+- Symbol Whale Activity: {'✅ Available' if symbol_whale_available else '❌ Not Available'}
+- News Data: {'✅ Available' if news_available else '❌ Not Available'}
+- Chart Patterns: {'✅ STRONG PATTERN' if pattern_available and pattern_analysis.get('pattern_confidence', 0) > 0.7 else '✅ WEAK PATTERN' if pattern_available else '❌ Not Available'}
+
+**⚠️ IMPORTANT: Decisions should be based ONLY on available real data.**
+**🎯 PATTERN PRIORITY: Give significant weight to chart patterns when available with high confidence.**
+"""
+
+    def _format_advanced_indicators(self, advanced_indicators):
+        if not advanced_indicators:
+            return "❌ No data for advanced indicators."
+        
+        summary = []
+        for timeframe, indicators in advanced_indicators.items():
+            if indicators:
+                parts = []
+                if 'rsi' in indicators: parts.append(f"RSI: {indicators['rsi']:.2f}")
+                if 'macd_hist' in indicators: parts.append(f"MACD Hist: {indicators['macd_hist']:.4f}")
+                if 'volume_ratio' in indicators: parts.append(f"Volume: {indicators['volume_ratio']:.2f}x")
+                if parts:
+                    summary.append(f"\n📊 **{timeframe}:** {', '.join(parts)}")
+        
+        return "\n".join(summary) if summary else "⚠️ Insufficient indicator data."
+
+    def _format_strategies_analysis(self, strategy_scores, recommended_strategy):
+        if not strategy_scores:
+            return "❌ No strategy data available."
+        
+        summary = [f"🎯 **Recommended Strategy:** {recommended_strategy}"]
+        sorted_scores = sorted(strategy_scores.items(), key=lambda item: item[1], reverse=True)
+        for strategy, score in sorted_scores:
+            if isinstance(score, (int, float)):
+                score_display = f"{score:.3f}"
+            else:
+                score_display = str(score)
+            summary.append(f"   • {strategy}: {score_display}")
+        
+        return "\n".join(summary)
+
+    def _format_pattern_analysis_enhanced(self, pattern_analysis, payload):
+        """تنسيق محسن لقسم تحليل النمط"""
+        if not pattern_analysis:
+            return """
+    ❌ **CHART PATTERN STATUS: NO CLEAR PATTERNS DETECTED**
+    - Reason: Insufficient data or no recognizable patterns in current chart
+    - Impact: Decision will rely more on technical indicators and market context
+    - Recommendation: Proceed with caution, use wider stops
+    """
+        
+        confidence = pattern_analysis.get('pattern_confidence', 0)
+        pattern_name = pattern_analysis.get('pattern_detected', 'unknown')
+        strength = pattern_analysis.get('pattern_strength', 'unknown')
+        
+        if confidence >= 0.7:
+            status = "✅ **HIGH-CONFIDENCE PATTERN DETECTED**"
+            influence = "This pattern should SIGNIFICANTLY influence your trading decision"
+        elif confidence >= 0.5:
+            status = "⚠️ **MEDIUM-CONFIDENCE PATTERN DETECTED**"
+            influence = "Consider this pattern but verify with other indicators"
+        else:
+            status = "📊 **LOW-CONFIDENCE PATTERN DETECTED**"
+            influence = "Use this pattern as supplementary information only"
+        
+        analysis_lines = [
+            status,
+            f"**Pattern:** {pattern_name}",
+            f"**Confidence:** {confidence:.1%}",
+            f"**Strength:** {strength}",
+            f"**Predicted Move:** {pattern_analysis.get('predicted_direction', 'N/A')} "
+            f"by {pattern_analysis.get('predicted_movement_percent', 0):.2f}%",
+            f"**Timeframe:** {pattern_analysis.get('timeframe_expectation', 'N/A')}",
+            f"**Influence:** {influence}",
+            "",
+            "**PATTERN-SPECIFIC SUGGESTIONS:**",
+            f"Entry: {pattern_analysis.get('entry_suggestion', 'N/A')}",
+            f"Target: {pattern_analysis.get('target_suggestion', 'N/A')}", 
+            f"Stop: {pattern_analysis.get('stop_suggestion', 'N/A')}",
+            f"Key Support: {pattern_analysis.get('key_support', 'N/A')}",
+            f"Key Resistance: {pattern_analysis.get('key_resistance', 'N/A')}",
+            "",
+            f"**Analysis:** {pattern_analysis.get('pattern_analysis', 'No detailed analysis available')}"
+        ]
+        
+        return "\n".join(analysis_lines)
+
+    def _format_whale_analysis_for_llm(self, general_whale_activity, symbol_whale_data, symbol):
+        analysis_parts = []
+        
+        if general_whale_activity.get('data_available', False):
+            critical_flag = " 🚨 CRITICAL ALERT" if general_whale_activity.get('critical_alert') else ""
+            analysis_parts.append(f"📊 **General Market:** {general_whale_activity.get('description', 'Activity detected')}{critical_flag}")
+        else:
+            analysis_parts.append("📊 **General Market:** No significant general whale data available")
+        
+        if symbol_whale_data.get('data_available', False):
+            analysis_parts.append(f"🎯 **{symbol} Specific:** {symbol_whale_data.get('description', 'Activity detected')}")
+        else:
+            analysis_parts.append(f"🎯 **{symbol} Specific:** No contract-based whale data available")
+        
+        return "\n".join(analysis_parts)
+
+    async def re_analyze_trade_async(self, trade_data: dict, processed_data: dict):
+        try:
+            symbol = trade_data['symbol']
+            original_strategy = trade_data.get('strategy', 'GENERIC')
+            
+            if not original_strategy or original_strategy == 'unknown':
+                original_strategy = trade_data.get('decision_data', {}).get('strategy', 'GENERIC')
+                print(f"🔧 Fixed missing original strategy for {symbol}: {original_strategy}")
+                
+            print(f"🧠 Starting LLM re-analysis for {symbol} with strategy: {original_strategy}...")
+            
+            news_text = await self.news_fetcher.get_news_for_symbol(symbol)
+            pattern_analysis = await self._get_pattern_analysis(processed_data)
+            prompt = self._create_enhanced_re_analysis_prompt(trade_data, processed_data, news_text, pattern_analysis)
+            
+            async with self.semaphore:
+                response = await self._call_llm(prompt)
+            
+            re_analysis_dict = self._parse_re_analysis_response_enhanced(response, original_strategy, symbol)
+            if re_analysis_dict:
+                re_analysis_dict['model_source'] = self.model_name
+                
+                final_strategy = re_analysis_dict.get('strategy')
+                if not final_strategy or final_strategy == 'unknown':
+                    re_analysis_dict['strategy'] = original_strategy
+                    print(f"🔧 Final re-analysis strategy correction for {symbol}: {original_strategy}")
+                else:
+                    print(f"✅ LLM re-analysis confirmed strategy '{final_strategy}' for {symbol}.")
+                    
+                print(f"✅ LLM re-analysis completed for {symbol} - Strategy: {re_analysis_dict['strategy']}")
+            else:
+                print(f"❌ LLM re-analysis failed for {symbol}")
+                return local_re_analyze_trade(trade_data, processed_data)
+            
+            return re_analysis_dict
+            
+        except Exception as e:
+            print(f"❌ Unexpected error in enhanced LLM re-analysis: {e}")
+            return local_re_analyze_trade(trade_data, processed_data)
+
+    def _parse_re_analysis_response_enhanced(self, response_text: str, fallback_strategy: str = 'GENERIC', symbol: str = 'unknown') -> dict:
+        """✅ الإصلاح النهائي: تحليل رد إعادة التحليل مع إعطاء الثقة لقراره"""
+        try:
+            json_match = re.search(r'```json\n(.*?)\n```', response_text, re.DOTALL)
+            if json_match:
+                json_str = json_match.group(1).strip()
+            else:
+                json_match = re.search(r'\{.*\}', response_text, re.DOTALL)
+                if json_match:
+                    json_str = json_match.group()
+                else:
+                    print(f"❌ No JSON found in re-analysis response for {symbol}: {response_text}")
+                    return None
+
+            decision_data = json.loads(json_str)
+
+            strategy_value = decision_data.get('strategy')
+            # 💡 التحقق: هل الاستراتيجية التي أرجعها النموذج صالحة؟
+            if not strategy_value or strategy_value == 'unknown' or strategy_value is None:
+                # إذا كانت غير صالحة، استخدم الاستراتيجية الأصلية كخطة بديلة آمنة
+                print(f"⚠️ LLM re-analysis returned invalid strategy '{strategy_value}' for {symbol}. Forcing fallback: {fallback_strategy}")
+                decision_data['strategy'] = fallback_strategy
+            else:
+                # إذا كانت صالحة، اعتمدها مباشرةً!
+                print(f"✅ LLM re-analysis confirmed strategy '{strategy_value}' for {symbol}.")
+
+            return decision_data
+
+        except Exception as e:
+            print(f"❌ Unexpected error parsing re-analysis response for {symbol}: {e}")
+            return None
+
+    def _create_enhanced_re_analysis_prompt(self, trade_data: dict, processed_data: dict, news_text: str, pattern_analysis: dict) -> str:
+        symbol = trade_data.get('symbol', 'N/A')
+        entry_price = trade_data.get('entry_price', 'N/A')
+        current_price = processed_data.get('current_price', 'N/A')
+        strategy = trade_data.get('strategy', 'GENERIC')
+        
+        if not strategy or strategy == 'unknown':
+            strategy = 'GENERIC'
+            
+        try:
+            price_change = ((current_price - entry_price) / entry_price) * 100
+            performance_status = "Profit" if price_change > 0 else "Loss"
+            price_change_display = f"{price_change:+.2f}%"
+        except (TypeError, ZeroDivisionError):
+            price_change_display = "N/A"
+            performance_status = "Unknown"
+            
+        indicators_summary = self._format_advanced_indicators(processed_data.get('advanced_indicators', {}))
+        pattern_summary = self._format_pattern_analysis_enhanced(pattern_analysis, processed_data)
+        whale_analysis_section = self._format_whale_analysis_for_llm(processed_data.get('sentiment_data', {}).get('general_whale_activity', {}), processed_data.get('whale_data', {}), symbol)
+
+        prompt = f"""
+        🔄 **ENHANCED TRADE RE-ANALYSIS WITH CHART PATTERNS**
+
+        You are re-analyzing an open trade with new market data and chart patterns.
+
+        **TRADE CONTEXT ({strategy} STRATEGY):**
+        - Original Strategy: {strategy}
+        - Symbol: {symbol}
+        - Entry Price: {entry_price} USDT
+        - Current Price: {current_price} USDT
+        - Current Performance: {price_change_display} ({performance_status})
+        - Original Strategy: {strategy}
+
+        **UPDATED CHART PATTERN ANALYSIS:**
+        {pattern_summary}
+
+        **NEW MARKET DATA:**
+        - Updated Technicals: {indicators_summary}
+        - Updated Whale Intel: {whale_analysis_section}
+        - Latest News: {news_text}
+
+        **DECISION STRATEGY FOR {strategy}:**
+        - If pattern shows MORE profit potential: UPDATE with new targets and time
+        - If pattern suggests WEAKNESS: CLOSE immediately
+        - If pattern still VALID but needs more time: UPDATE with extended timing
+        - If pattern INVALIDATED: CLOSE to protect capital
+
+        **PATTERN-BASED DECISION GUIDELINES:**
+        - High-confidence patterns (>70%): Give them primary decision weight
+        - Medium-confidence patterns (50-70%): Use as supporting evidence
+        - Low-confidence patterns (<50%): Use cautiously with other factors
+
+        **REQUIRED OUTPUTS (JSON ONLY):**
+        - `action`: Must be ("HOLD", "CLOSE_TRADE", "UPDATE_TRADE")
+        - `reasoning`: Justification based on new data AND pattern analysis
+        - `new_stop_loss`: New stop loss if updating (consider pattern levels)
+        - `new_take_profit`: New take profit if updating (consider pattern targets)
+        - `new_expected_minutes`: New expected time if updating (null otherwise)
+        - `confidence_level`: Confidence in this decision (0.00-1.00)
+        - `strategy`: "{strategy}"  # ⚠️ MUST BE EXACTLY: {strategy}
+        - `pattern_influence_reanalysis`: "Describe how updated pattern analysis affected decision"
+
+        **CRITICAL: You MUST include the 'strategy' field with the exact value: "{strategy}"**
+        """
+        return prompt
+
+    @_rate_limit_nvidia_api
+    async def _call_llm(self, prompt: str) -> str:
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=self.temperature,
+                seed=42
+            )
+            return response.choices[0].message.content
+        except (RateLimitError, APITimeoutError) as e:
+            print(f"❌ LLM API Error: {e}. Retrying...")
+            raise
+        except Exception as e:
+            print(f"❌ Unexpected LLM API error: {e}")
+            raise
+
+# نظام تتبع أداء الأنماط
+class PatternPerformanceTracker:
+    def __init__(self):
+        self.pattern_success_rates = {}
+        self.pattern_history = []
+    
+    async def track_pattern_performance(self, trade_data, pattern_analysis, outcome, profit_percent):
+        """تتبع أداء الأنماط المختلفة"""
+        pattern_name = pattern_analysis.get('pattern_detected', 'unknown')
+        confidence = pattern_analysis.get('pattern_confidence', 0)
+        
+        if pattern_name not in self.pattern_success_rates:
+            self.pattern_success_rates[pattern_name] = {
+                'success_count': 0,
+                'total_count': 0,
+                'total_profit': 0,
+                'avg_profit': 0,
+                'confidence_sum': 0,
+                'avg_confidence': 0
+            }
+        
+        stats = self.pattern_success_rates[pattern_name]
+        stats['total_count'] += 1
+        stats['confidence_sum'] += confidence
+        
+        success = outcome in ["SUCCESS", "CLOSED_BY_REANALYSIS", "CLOSED_BY_MONITOR"] and profit_percent > 0
+        if success:
+            stats['success_count'] += 1
+            stats['total_profit'] += profit_percent
+            stats['avg_profit'] = stats['total_profit'] / stats['success_count']
+        
+        stats['avg_confidence'] = stats['confidence_sum'] / stats['total_count']
+        
+        success_rate = stats['success_count'] / stats['total_count']
+        
+        # تسجيل التاريخ
+        self.pattern_history.append({
+            'timestamp': datetime.now().isoformat(),
+            'pattern': pattern_name,
+            'confidence': confidence,
+            'success': success,
+            'profit_percent': profit_percent,
+            'symbol': trade_data.get('symbol', 'unknown')
+        })
+        
+        print(f"📊 Pattern {pattern_name}: Success Rate {success_rate:.1%}, Avg Profit: {stats['avg_profit']:.2f}%, Avg Confidence: {stats['avg_confidence']:.1%}")
+        
+        return success_rate
+
+    def get_pattern_recommendations(self):
+        """الحصول على توصيات بناءً على أداء الأنماط"""
+        recommendations = []
+        
+        for pattern, stats in self.pattern_success_rates.items():
+            if stats['total_count'] >= 3:  # على الأقل 3 صفقات لتكوين توصية
+                success_rate = stats['success_count'] / stats['total_count']
+                
+                if success_rate > 0.7:
+                    recommendations.append(f"✅ **{pattern}**: Excellent performance ({success_rate:.1%} success) - Prioritize this pattern")
+                elif success_rate > 0.5:
+                    recommendations.append(f"⚠️ **{pattern}**: Good performance ({success_rate:.1%} success) - Use with confidence")
+                elif success_rate < 0.3:
+                    recommendations.append(f"❌ **{pattern}**: Poor performance ({success_rate:.1%} success) - Use cautiously")
+        
+        return recommendations
+
+# إنشاء نسخة عالمية من متتبع الأداء
+pattern_tracker_global = PatternPerformanceTracker()
+
+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', [])
+    
+    strategy = candidate_data.get('target_strategy', 'GENERIC')
+    
+    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": strategy
+        }
+    
+    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": strategy
+        }
+    
+    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_five_minute = five_minute_indicators.get('rsi', 50)
+    if 30 <= rsi_five_minute <= 65:
+        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
+    
+    if rsi_warning:
+        confidence *= 0.7
+        reasoning += " RSI warning applied."
+    
+    if confidence >= 0.6:
+        action = "BUY"
+        current_price = candidate_data['current_price']
+        trade_type = "LONG"
+        
+        if rsi_warning:
+            stop_loss = current_price * 0.93
+        else:
+            stop_loss = current_price * 0.95
+        
+        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. Strategy: {strategy}. 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": strategy
+    }
+
+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 LLM Service loaded successfully - ADVANCED PATTERN ANALYSIS - Performance Tracking - Real-time Pattern Integration")

ML (31).py

@@ -0,0 +1,1402 @@
+# ML.py - الإصدار المحدث مع إصلاح الأخطاء الحرجة
+import pandas as pd
+import pandas_ta as ta
+import numpy as np
+from datetime import datetime
+import asyncio
+from data_manager import DataManager
+
+class AdvancedTechnicalAnalyzer:
+    def __init__(self):
+        self.indicators_config = {
+            'trend': ['ema_9', 'ema_21', 'ema_50', 'ema_200', 'ichimoku', 'adx', 'parabolic_sar', 'dmi'],
+            'momentum': ['rsi', 'stoch_rsi', 'macd', 'williams_r', 'cci', 'awesome_oscillator', 'momentum'],
+            'volatility': ['bbands', 'atr', 'keltner', 'donchian', 'rvi'],
+            'volume': ['vwap', 'obv', 'mfi', 'volume_profile', 'ad', 'volume_oscillator'],
+            'cycle': ['hull_ma', 'supertrend', 'zigzag', 'fisher_transform']
+        }
+    
+    def calculate_all_indicators(self, dataframe, timeframe):
+        if dataframe.empty: 
+            return {}
+        indicators = {}
+        indicators.update(self._calculate_trend_indicators(dataframe))
+        indicators.update(self._calculate_momentum_indicators(dataframe))
+        indicators.update(self._calculate_volatility_indicators(dataframe))
+        indicators.update(self._calculate_volume_indicators(dataframe))
+        indicators.update(self._calculate_cycle_indicators(dataframe))
+        return indicators
+    
+    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) >= 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 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 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
+        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 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 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 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 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 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 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
+        return {key: value for key, value in momentum.items() if value is not None}
+    
+    def _calculate_volatility_indicators(self, dataframe):
+        volatility = {}
+        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 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 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 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 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
+        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
+        
+        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 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
+        
+        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 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
+        
+        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'])
+        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 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 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
+        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
+            
+        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% زيادة
+        
+        # أنماط عالية المصداقية تحصل على تعزيز إضافي
+        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% زيادة
+    
+    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 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
+            
+        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
+                }
+            
+            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  # قيمة افتراضية
+
+class MultiStrategyEngine:
+    def __init__(self, data_manager, learning_engine):
+        self.data_manager = data_manager
+        self.learning_engine = learning_engine
+        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:
+            # ✅ الحصول على الأوزان المحسنة من نظام التعلم
+            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}")
+                    optimized_weights = await self.get_default_weights()
+            else:
+                print("⚠️ نظام التعلم غير متوفر، استخدام الأوزان الافتراضية")
+                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)
+                    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 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)):
+                    
+                    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  # ✅ إرجاع كلا النوعين
+            
+        except Exception as error:
+            print(f"❌ فشل تقييم الاستراتيجيات: {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
+            
+        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
+        }
+
+    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
+        }
+
+    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 للقوة الاتجاهية
+                    adx_value = timeframe_indicators.get('adx', 0)
+                    if adx_value > 20:  # ⬇️ تخفيض من 25 إلى 20
+                        score += 0.15  # ⬆️ زيادة من 0.1 إلى 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
+            
+            # ✅ تعزيز بناءً على تحليل الأنماط
+            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'):
+                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 (نفس القيمة)
+    
+    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']
+                
+                # تحليل 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
+                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
+            
+            # ✅ تعزيز بناءً على تحليل الأنماط
+            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']):
+                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 إضافية
+                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 إضافي
+                    rsi_value = timeframe_indicators.get('rsi', 50)
+                    if 40 <= rsi_value <= 70:  # نطاق RSI صحي
+                        score += 0.10
+            
+            # ✅ تعزيز بناءً على تحليل الأنماط - تأثير كبير على breakout
+            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 إذا كانت هناك إشارات
+                
+            return min(score, 1.0)
+            
+        except Exception as error:
+            print(f"⚠️ Breakout momentum strategy error: {error}")
+            return 0.4  # ⬆️ زيادة من 0.3 إلى 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
+            
+            # ✅ تعزيز بناءً على تحليل الأنماط مع ارتفاع الحجم
+            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)):
+                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 (قيمة أساسية أعلى)
+                
+            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
+                
+            # ✅ إضافة نقاط إضافية بناءً على نشاط الحيتان العام
+            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
+                
+            return min(score, 1.0)
+            
+        except Exception as error: 
+            print(f"⚠️ Whale tracking failed: {error}")
+            return 0.2  # ⬆️ زيادة من 0.1 إلى 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
+            
+            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
+            
+            # تحليل نشاط الحيتان العام
+            whale_activity = market_context.get('general_whale_activity', {})
+            if whale_activity.get('sentiment') == 'BULLISH':
+                score += 0.15  # ⬆️ زيادة من 0.1 إلى 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
+                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
+                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
+                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
+                    
+                total_transactions = whale_data.get('transfer_count', 0)
+                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
+
+class MLProcessor:
+    def __init__(self, market_context, data_manager, learning_engine):
+        self.market_context = market_context
+        self.data_manager = data_manager
+        self.learning_engine = learning_engine
+        self.technical_analyzer = AdvancedTechnicalAnalyzer()
+        self.strategy_engine = MultiStrategyEngine(data_manager, learning_engine)
+        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:
+                rsi_value = indicators[timeframe].get('rsi')
+                if rsi_value:
+                    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")
+        
+        # إذا كان هناك إطارين زمنيين أو أكثر في منطقة الخطر، نرفض المرشح
+        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
+        
+        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 '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")
+        
+        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
+        
+        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
+            
+            # ✅ تمرير بيانات الشموع الخام للتحليل اللاحق
+            raw_data['raw_ohlcv'] = raw_data.get('ohlcv', {})
+            
+            base_analysis = await self.process_and_score_symbol(raw_data)
+            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
+                )
+                
+                # طباعة تحذيرات الجودة
+                if quality_issues:
+                    print(f"🔍 Quality issues for {base_analysis.get('symbol')}:")
+                    for issue in quality_issues:
+                        print(f"   {issue}")
+                
+                # ✅ تقييم الاستراتيجيات باستخدام نظام التعلم مع التحقق من الوجود
+                if hasattr(self, 'strategy_engine') and self.strategy_engine:
+                    strategy_scores, base_scores = await self.strategy_engine.evaluate_all_strategies(base_analysis, self.market_context)
+                    base_analysis['strategy_scores'] = strategy_scores
+                    base_analysis['base_strategy_scores'] = base_scores  # ✅ حفظ الدرجات الأساسية
+                    
+                    # ✅ تحديد أفضل استراتيجية بناءً على الدرجات الأساسية (بدون أوزان)
+                    if base_scores:
+                        best_strategy = max(base_scores.items(), key=lambda x: x[1])
+                        best_strategy_name = best_strategy[0]
+                        best_strategy_score = best_strategy[1]
+                        
+                        base_analysis['recommended_strategy'] = best_strategy_name
+                        base_analysis['strategy_confidence'] = best_strategy_score
+                        
+                        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})")
+                    else:
+                        base_analysis['recommended_strategy'] = 'GENERIC'
+                        base_analysis['strategy_confidence'] = 0.3  # ⬆️ زيادة من 0.5 إلى 0.3
+                        base_analysis['target_strategy'] = 'GENERIC'
+                        print("🔄 استخدام استراتيجية عامة (لا توجد درجات استراتيجية)")
+                    
+                    # ✅ استخدام الدالة المحسنة لحساب النقاط
+                    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['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 يومًا لحساب القمة والقاع
+        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%
+        
+        difference = recent_high - recent_low
+        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,
+            "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
+            
+        try:
+            all_indicators = {}
+            for timeframe, candles in ohlcv_data.items():
+                if candles:
+                    dataframe = pd.DataFrame(candles, columns=['time', 'open', 'high', 'low', 'close', 'volume'])
+                    dataframe[['open', 'high', 'low', 'close', 'volume']] = dataframe[['open', 'high', 'low', 'close', 'volume']].astype(float)
+                    all_indicators[timeframe] = self._calculate_indicators(dataframe, timeframe)
+            
+            hourly_dataframe = pd.DataFrame(ohlcv_data.get('1h', []), columns=['time', 'open', 'high', 'low', 'close', 'volume'])
+            if hourly_dataframe.empty: 
+                print(f"❌ Skipping {symbol} due to insufficient 1h data.")
+                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'):
+                    five_minute_dataframe = pd.DataFrame(ohlcv_data['5m'], columns=['time', 'open', 'high', 'low', 'close', 'volume'])
+                    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)
+                    
+                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)
+                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
+                    }
+                    
+                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),
+                    'whale_data': whale_data, 'whale_score': float(whale_score), 'opportunity_type': opportunity_classification, 
+                    'sentiment_data': self.market_context, 'fibonacci_levels': fibonacci_levels, 'final_score': float(final_score),
+                    '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  # ✅ إضافة بيانات الشموع الخام
+                }
+                
+            except (KeyError, IndexError) as error: 
+                print(f"⚠️ Missing data for {symbol}: {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 not isinstance(dataframe.index, pd.DatetimeIndex):
+            try:
+                dataframe['time'] = pd.to_datetime(dataframe['time'], unit='ms')
+                dataframe = dataframe.set_index('time', drop=True)
+            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 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 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 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 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 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])
+                
+        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
+            else:
+                try:
+                    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
+        log_returns = np.log(dataframe['close'] / dataframe['close'].shift(1)).dropna()
+        if log_returns.empty: 
+            return 0.0
+        mean_return = log_returns.mean()
+        volatility = log_returns.std()
+        initial_price = dataframe['close'].iloc[-1]
+        success_count = 0
+        for _ in range(number_of_simulations):
+            random_values = np.random.normal(0, 1, number_of_steps)
+            daily_returns = np.exp(mean_return - 0.5 * volatility**2 + volatility * random_values)
+            simulated_prices = initial_price * daily_returns.cumprod()
+            if (simulated_prices[-1] / initial_price) > 1.02: 
+                success_count += 1
+        return success_count / number_of_simulations
+
+    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 '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 all(key in timeframe_indicators for key in ['ema_12', 'ema_26']):
+                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 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 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 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
+        return min(max(score, 0.0), 1.0)
+    
+    def _normalize_features(self, features):
+        return self._normalize_features_corrected(features)
+
+    def _prepare_data_for_ml(self, all_indicators, current_price):
+        feature_vector = []
+        timeframes = ['5m', '15m', '1h', '4h', '1d']
+        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))
+        feature_vector.append(current_price)
+        return feature_vector
+        
+    def _calculate_liquidity_score(self, hourly_dataframe):
+        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 classify_opportunity_type(self, indicators, current_price):
+        fast_signals = 0
+        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 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
+        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 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 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": "فرصة صعود سريع قوية على الأطر الزمنية القصيرة"
+            }
+        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": "فرصة نمو مستدام على الأطر الزمنية الطويلة"
+            }
+        return {
+            "type": "NEUTRAL", "timeframe": "N/A", "take_profit_multiplier": 1.05, "stop_loss_multiplier": 0.95, 
+            "confidence": 0.3, "description": "لا توجد إشارات واضحة لنوع محدد من الفرص"
+        }
+    
+    def _calculate_whale_activity_score(self, whale_data):
+        """حساب درجة نشاط الحيتان بناءً على البيانات الحقيقية فقط"""
+        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
+            
+        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")

app (32).py

@@ -0,0 +1,953 @@
+# app.py - الإصدار المحدث مع إصلاح الأخطاء الحرجة
+import os
+import traceback
+import signal
+import sys
+import uvicorn
+import asyncio
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, BackgroundTasks, HTTPException
+from datetime import datetime, timedelta
+from r2 import R2Service
+from LLM import LLMService, local_analyze_opportunity, local_re_analyze_trade
+from data_manager import DataManager
+from ML import MLProcessor as FeatureProcessor
+from learning_engine import LearningEngine
+import time
+import json
+import state
+import re
+
+# إعدادات النظام
+TOP_N_SYMBOLS = 100
+OPPORTUNITY_COUNT = 10
+CHUNK_SIZE = 5
+
+# المتغيرات العامة للنظام
+r2_service_global = None
+data_manager_global = None
+llm_service_global = None
+learning_engine_global = None
+realtime_monitor = None
+
+# Real-time trade monitoring with enhanced risk management
+class RealTimeTradeMonitor:
+    def __init__(self):
+        self.monitoring_tasks = {}
+        self.is_running = False
+        
+    async def start_monitoring(self):
+        """بدء مراقبة جميع الصفقات المفتوحة"""
+        self.is_running = True
+        print("🔍 Starting real-time trade monitoring...")
+        
+        while self.is_running:
+            try:
+                open_trades = await r2_service_global.get_open_trades_async()
+                
+                for trade in open_trades:
+                    symbol = trade['symbol']
+                    if symbol not in self.monitoring_tasks:
+                        asyncio.create_task(self._monitor_single_trade(trade))
+                        self.monitoring_tasks[symbol] = trade
+                
+                current_symbols = {trade['symbol'] for trade in open_trades}
+                for symbol in list(self.monitoring_tasks.keys()):
+                    if symbol not in current_symbols:
+                        del self.monitoring_tasks[symbol]
+                
+                await asyncio.sleep(10)
+                
+            except Exception as error:
+                print(f"❌ Real-time monitor error: {error}")
+                await asyncio.sleep(30)
+    
+    async def _monitor_single_trade(self, trade):
+        """مراقبة صفقة فردية في الوقت الحقيقي"""
+        symbol = trade['symbol']
+        strategy = trade.get('strategy', 'GENERIC')
+        print(f"📊 Starting real-time monitoring for {symbol} (Strategy: {strategy})")
+        
+        while symbol in self.monitoring_tasks and self.is_running:
+            try:
+                current_price = await data_manager_global.get_latest_price_async(symbol)
+                if not current_price:
+                    await asyncio.sleep(15)
+                    continue
+                
+                entry_price = trade['entry_price']
+                stop_loss = trade.get('stop_loss')
+                take_profit = trade.get('take_profit')
+                
+                should_close = False
+                close_reason = ""
+                
+                if stop_loss and current_price <= stop_loss:
+                    should_close = True
+                    close_reason = f"Stop loss hit: {current_price} <= {stop_loss}"
+                elif take_profit and current_price >= take_profit:
+                    should_close = True
+                    close_reason = f"Take profit hit: {current_price} >= {take_profit}"
+                
+                if not should_close and current_price > entry_price:
+                    dynamic_stop = current_price * 0.98
+                    if dynamic_stop > (stop_loss or 0):
+                        trade['stop_loss'] = dynamic_stop
+                        print(f"🔒 Updated trailing stop for {symbol}: {dynamic_stop:.4f}")
+                
+                if should_close:
+                    print(f"🚨 IMMEDIATE CLOSE: {symbol} - {close_reason} - Strategy: {strategy}")
+                    
+                    if r2_service_global.acquire_lock():
+                        try:
+                            await r2_service_global.close_trade_async(trade, current_price)
+                            print(f"✅ Trade {symbol} closed immediately at {current_price}. Strategy: {strategy}")
+                            
+                            if learning_engine_global and learning_engine_global.initialized:
+                                await learning_engine_global.analyze_trade_outcome(trade, 'CLOSED_BY_MONITOR')
+                            
+                            asyncio.create_task(run_bot_cycle_async())
+                            
+                        finally:
+                            r2_service_global.release_lock()
+                    
+                    if symbol in self.monitoring_tasks:
+                        del self.monitoring_tasks[symbol]
+                    break
+                
+                await asyncio.sleep(15)
+                
+            except Exception as error:
+                print(f"❌ Real-time monitoring error for {symbol}: {error}")
+                await asyncio.sleep(30)
+    
+    def stop_monitoring(self):
+        """إيقاف جميع مهام المراقبة"""
+        self.is_running = False
+        self.monitoring_tasks.clear()
+        print("🛑 Real-time trade monitoring stopped")
+
+async def monitor_market_async():
+    """Background task to continuously monitor market health"""
+    global data_manager_global
+    
+    init_attempts = 0
+    while data_manager_global is None and init_attempts < 10:
+        print(f"⏳ Waiting for data manager initialization... (attempt {init_attempts + 1}/10)")
+        await asyncio.sleep(3)
+        init_attempts += 1
+    
+    if data_manager_global is None:
+        print("❌ Data manager failed to initialize after 10 attempts")
+        return
+    
+    while True:
+        try:
+            print("👁️ Monitoring market sentiment...")
+            
+            try:
+                market_context = await data_manager_global.get_market_context_async()
+            except Exception as error:
+                print(f"⚠️ Failed to get market context: {error}")
+                market_context = await get_fallback_market_context()
+            
+            if not market_context:
+                print("❌ Failed to get market context. Assuming neutral state.")
+                state.MARKET_STATE_OK = True
+                await asyncio.sleep(60)
+                continue
+
+            whale_analysis = market_context.get('general_whale_activity', {})
+            whale_sentiment = whale_analysis.get('sentiment', 'NEUTRAL')
+            is_critical = whale_analysis.get('critical_alert', False)
+            total_volume = whale_analysis.get('total_volume_usd', 0)
+
+            print(f"🐋 Whale Analysis: {whale_sentiment} | Critical: {is_critical} | Volume: ${total_volume:,.0f}")
+            print(f"📈 Whale Description: {whale_analysis.get('description', 'No data')}")
+
+            bitcoin_sentiment = market_context.get('btc_sentiment')
+            fear_greed_index = market_context.get('fear_and_greed_index')
+            
+            should_halt_trading = False
+            halt_reason = ""
+            
+            if is_critical:
+                should_halt_trading = True
+                halt_reason = f"CRITICAL whale activity detected: {whale_analysis.get('description')}"
+            elif bitcoin_sentiment == 'BEARISH' and (fear_greed_index is not None and fear_greed_index < 30):
+                should_halt_trading = True
+                halt_reason = f"Bearish market conditions (BTC: {bitcoin_sentiment}, F&G: {fear_greed_index})"
+
+            if should_halt_trading:
+                print(f"🚨🚨🚨 MARKET HALT: {halt_reason} 🚨🚨🚨")
+                state.MARKET_STATE_OK = False
+                
+                try:
+                    await r2_service_global.save_system_logs_async({
+                        "market_halt": True,
+                        "reason": halt_reason,
+                        "whale_sentiment": whale_sentiment,
+                        "is_critical": is_critical
+                    })
+                except Exception as log_error:
+                    print(f"⚠️ Failed to save market halt log: {log_error}")
+            else:
+                if not state.MARKET_STATE_OK:
+                    print("🟢 Market conditions improved. Resuming normal operations.")
+                state.MARKET_STATE_OK = True
+                
+            await asyncio.sleep(60)
+        except Exception as error:
+            print(f"❌ An error occurred during COMPREHENSIVE market monitoring: {error}")
+            traceback.print_exc()
+            state.MARKET_STATE_OK = True
+            await asyncio.sleep(60)
+
+async def get_fallback_market_context():
+    """Fallback function when main market context fails"""
+    return {
+        'timestamp': datetime.now().isoformat(),
+        'general_whale_activity': {
+            'sentiment': 'NEUTRAL', 
+            'description': 'Fallback mode - system initializing',
+            'critical_alert': False,
+            'transaction_count': 0,
+            'total_volume_usd': 0
+        },
+        'btc_sentiment': 'NEUTRAL',
+        'fear_and_greed_index': 50
+    }
+
+def safe_float_conversion(value, default=0.0):
+    """تحويل آمن للقيم إلى أرقام"""
+    try:
+        if value is None:
+            return default
+        if isinstance(value, (int, float)):
+            return float(value)
+        if isinstance(value, str):
+            cleaned = ''.join(character for character in value if character.isdigit() or character in '.-')
+            return float(cleaned) if cleaned else default
+        return default
+    except (ValueError, TypeError):
+        return default
+
+async def validate_candidate_data_enhanced(candidate):
+    """✨ تحسين التحقق من جودة المرشحين"""
+    try:
+        required_fields = ['symbol', 'current_price', 'final_score', 'enhanced_final_score']
+        
+        for field in required_fields:
+            if field not in candidate:
+                candidate[field] = 0.0 if field.endswith('_score') or field == 'current_price' else 'UNKNOWN'
+        
+        candidate['current_price'] = safe_float_conversion(candidate.get('current_price'), 0.0)
+        candidate['final_score'] = safe_float_conversion(candidate.get('final_score'), 0.5)
+        candidate['enhanced_final_score'] = safe_float_conversion(candidate.get('enhanced_final_score'), candidate['final_score'])
+        
+        if 'reasons_for_candidacy' not in candidate or not candidate['reasons_for_candidacy']:
+            candidate['reasons_for_candidacy'] = ['unknown_reason']
+            
+        if 'sentiment_data' not in candidate or not candidate['sentiment_data']:
+            candidate['sentiment_data'] = {
+                'btc_sentiment': 'NEUTRAL',
+                'fear_and_greed_index': 50,
+                'general_whale_activity': {'sentiment': 'NEUTRAL', 'critical_alert': False}
+            }
+            
+        if 'advanced_indicators' not in candidate:
+            candidate['advanced_indicators'] = {}
+            
+        if 'strategy_scores' not in candidate:
+            candidate['strategy_scores'] = {}
+            
+        if 'recommended_strategy' not in candidate:
+            candidate['recommended_strategy'] = 'unknown'
+        
+        # ✅ الإصلاح: التأكد من وجود استراتيجية مستهدفة صالحة
+        if 'target_strategy' not in candidate or not candidate['target_strategy'] or candidate['target_strategy'] == 'unknown':
+            candidate['target_strategy'] = 'GENERIC'
+            
+        return True
+        
+    except Exception as error:
+        print(f"❌ Failed to validate candidate data for {candidate.get('symbol')}: {error}")
+        return False
+
+async def analyze_market_strategy(market_context):
+    """تحديد الاستراتيجية المثلى بناءً على ظروف السوق"""
+    try:
+        prompt = f"""
+        You are a professional crypto portfolio manager. Analyze the current market conditions and determine the most suitable strategy.
+
+        **Market Data:**
+        - BTC Price: {market_context.get('bitcoin_price_usd')}
+        - BTC Sentiment: {market_context.get('btc_sentiment')}
+        - Fear & Greed Index: {market_context.get('fear_and_greed_index')}
+        - Whale Analysis: {market_context.get('general_whale_activity', {}).get('sentiment')}
+        - Critical Whale Alert: {market_context.get('general_whale_activity', {}).get('critical_alert')}
+
+        **Available Strategies:**
+        1. AGGRESSIVE_GROWTH - For strong bull markets.
+        2. DEFENSIVE_GROWTH - For volatile or uncertain markets.
+        3. CONSERVATIVE - For bearish or high-risk markets.
+        4. HIGH_FREQUENCY - For sideways markets.
+        5. WHALE_FOLLOWING - When whale activity is high and clear.
+        6. GENERIC - Balanced approach for normal conditions.
+
+        **Required:**
+        - Choose one primary strategy.
+        - Explain why in a single sentence.
+        - Set an acceptable risk tolerance (1 to 10).
+        - Determine the optimal number of coins to scan (50 to 200).
+
+        **Output (JSON only):**
+        {{
+            "primary_strategy": "STRATEGY_NAME",
+            "reasoning": "Brief reasoning.",
+            "risk_tolerance": 5,
+            "optimal_scan_count": 100
+        }}
+        """
+        
+        response = await llm_service_global._call_llm(prompt)
+        
+        try:
+            json_match = re.search(r'\{.*\}', response, re.DOTALL)
+            strategy_data = json.loads(json_match.group())
+        except:
+            strategy_data = {
+                "primary_strategy": "GENERIC",
+                "reasoning": "Fallback strategy for market stability",
+                "risk_tolerance": 5,
+                "optimal_scan_count": 100,
+            }
+        
+        return strategy_data
+        
+    except Exception as error:
+        print(f"❌ Failed to analyze market strategy: {error}")
+        return {
+            "primary_strategy": "GENERIC",
+            "reasoning": "Fallback due to analysis error",
+            "risk_tolerance": 5,
+            "optimal_scan_count": 100,
+        }
+
+async def find_strategy_specific_candidates(strategy, scan_count):
+    """✨ نظام فلترة ذكي يستخدم الاستراتيجيات المتخصصة - عتبات مخفضة"""
+    try:
+        # 1. جلب قائمة المرشحين الأولية
+        all_candidates = await data_manager_global.find_high_potential_candidates(scan_count * 2)
+        
+        if not all_candidates:
+            print(f"⚠️ الماسح العام لم يجد أي مرشحين أوليين.")
+            return []
+
+        # 2. تحديث market_context قبل المعالجة
+        market_context = await data_manager_global.get_market_context_async()
+        if not market_context:
+            print("❌ Failed to get market context for strategy analysis")
+            return []
+            
+        feature_processor = FeatureProcessor(market_context, data_manager_global, learning_engine_global)
+        
+        processed_candidates = []
+        for candidate in all_candidates[:30]:  # ⬇️ تخفيض من 50 إلى 30 للأداء
+            try:
+                # تحويل البيانات الخام إلى بيانات معالجة
+                symbol_with_reasons = [{'symbol': candidate['symbol'], 'reasons': candidate.get('reasons', [])}]
+                ohlcv_data = await data_manager_global.get_fast_pass_data_async(symbol_with_reasons)
+                
+                if ohlcv_data and ohlcv_data[0]:
+                    # ✅ تحديث market_context قبل كل معالجة لمنع الخطأ
+                    try:
+                        updated_market_context = await data_manager_global.get_market_context_async()
+                        if updated_market_context:
+                            feature_processor.market_context = updated_market_context
+                    except Exception as e:
+                        print(f"⚠️ Failed to update market context for {candidate['symbol']}: {e}")
+                        # الاستمرار بالسياق القديم إذا فشل التحديث
+                    
+                    processed = await feature_processor.process_and_score_symbol_enhanced(ohlcv_data[0])
+                    if processed:
+                        processed_candidates.append(processed)
+            except Exception as e:
+                print(f"⚠️ فشل معالجة {candidate.get('symbol')}: {e}")
+        
+        if not processed_candidates:
+            print("⚠️ لم يتم معالجة أي مرشح بنجاح")
+            return []
+        
+        # 3. فرز المرشحين حسب الاستراتيجية المطلوبة
+        if strategy != 'GENERIC':
+            # تحديد أفضل المرشحين للاستراتيجية المحددة
+            strategy_candidates = []
+            for candidate in processed_candidates:
+                # ✅ استخدام الدرجات الأساسية بدلاً من المرجحة
+                base_scores = candidate.get('base_strategy_scores', {})
+                strategy_score = base_scores.get(strategy, 0)
+                
+                # ✅ تخفيض كبير في عتبة القبول
+                if strategy_score > 0.2:  # ⬇️ تخفيض من 0.4 إلى 0.2
+                    candidate['strategy_match_score'] = strategy_score
+                    strategy_candidates.append(candidate)
+                    print(f"✅ {candidate['symbol']} مناسب لـ {strategy} (درجة: {strategy_score:.3f})")
+            
+            # فرز حسب تطابق الاستراتيجية
+            sorted_candidates = sorted(strategy_candidates, 
+                                    key=lambda x: x.get('strategy_match_score', 0), 
+                                    reverse=True)
+            top_candidates = sorted_candidates[:15]  # ⬇️ تخفيض من 20 إلى 15
+            
+            print(f"✅ تم اختيار {len(top_candidates)} مرشحًا لاستراتيجية {strategy}")
+        else:
+            # للاستراتيجية العامة، استخدم النقاط المحسنة
+            sorted_candidates = sorted(processed_candidates, 
+                                    key=lambda x: x.get('enhanced_final_score', 0), 
+                                    reverse=True)
+            top_candidates = sorted_candidates[:15]  # ⬇️ تخفيض من 20 إلى 15
+            print(f"✅ تم اختيار {len(top_candidates)} مرشحًا للاستراتيجية العامة")
+
+        return top_candidates
+
+    except Exception as error:
+        print(f"❌ فشل في نظام الفلترة المتقدم: {error}")
+        traceback.print_exc()
+        return []
+
+async def find_new_opportunities_async():
+    """✨ NEW: المسح المحسن باستراتيجية مسبقة مع عتبات مخفضة"""
+    print("🔍 Scanning for new opportunities with reduced thresholds...")
+    try:
+        await r2_service_global.save_system_logs_async({
+            "opportunity_scan_started": True, "timestamp": datetime.now().isoformat()
+        })
+
+        print("🧠 Determining trading strategy...")
+        market_context = await data_manager_global.get_market_context_async()
+        if not market_context:
+            print("❌ Failed to fetch market context. Cannot determine strategy.")
+            return
+
+        strategy_decision = await analyze_market_strategy(market_context)
+        
+        print(f"🎯 Selected Strategy: {strategy_decision['primary_strategy']}")
+        print(f"📝 Reasoning: {strategy_decision['reasoning']}")
+        print(f"⚡ Risk Tolerance: {strategy_decision.get('risk_tolerance', 5)}/10")
+        print(f"🔍 Optimal Scan Count: {strategy_decision.get('optimal_scan_count', 100)}")
+
+        print(f"🔍 Finding top candidates using dynamic ranking...")
+        high_potential_candidates = await find_strategy_specific_candidates(
+            strategy_decision['primary_strategy'], 
+            strategy_decision.get('optimal_scan_count', 100)
+        )
+        
+        if not high_potential_candidates:
+            print("🔄 لا توجد مرشحين متخصصين، جلب مرشحين عامين...")
+            # ✅ استرجاع مرشحين عامين كبديل
+            high_potential_candidates = await data_manager_global.find_high_potential_candidates(20)
+            if high_potential_candidates:
+                for candidate in high_potential_candidates:
+                    candidate['target_strategy'] = 'GENERIC'
+                print(f"✅ تم تحميل {len(high_potential_candidates)} مرشح عام")
+            else:
+                print("✅ No new candidates found after dynamic ranking.")
+                await r2_service_global.save_system_logs_async({
+                    "no_candidates_found": True, "strategy": strategy_decision['primary_strategy'],
+                    "reason": "Scanner did not return any initial candidates."
+                })
+                return
+
+        all_processed_candidates = []
+        for index in range(0, len(high_potential_candidates), CHUNK_SIZE):
+            chunk = high_potential_candidates[index:index+CHUNK_SIZE]
+            
+            chunk_data = await data_manager_global.get_fast_pass_data_async(chunk)
+            
+            print(f"⏳ Processing and scoring chunk {index//CHUNK_SIZE + 1}...")
+            # ✅ تحديث market_context قبل معالجة كل شريحة
+            updated_market_context = await data_manager_global.get_market_context_async()
+            if not updated_market_context:
+                updated_market_context = market_context  # استخدام السياق القديم كبديل
+                
+            feature_processor = FeatureProcessor(updated_market_context, data_manager_global, learning_engine_global)
+            
+            processed_chunk = await asyncio.gather(*[
+                feature_processor.process_and_score_symbol_enhanced(data) for data in chunk_data
+            ])
+            all_processed_candidates.extend([c for c in processed_chunk if c is not None])
+            
+            await asyncio.sleep(1)
+
+        if not all_processed_candidates:
+            print("❌ No candidates were processed successfully.")
+            return
+
+        # ✅ استخدام السياق المحدث للتصفية النهائية
+        updated_market_context = await data_manager_global.get_market_context_async()
+        if not updated_market_context:
+            updated_market_context = market_context
+            
+        feature_processor = FeatureProcessor(updated_market_context, data_manager_global, learning_engine_global)
+        top_candidates = feature_processor.filter_top_candidates(all_processed_candidates, OPPORTUNITY_COUNT)
+        
+        print(f"✅ Identified {len(top_candidates)} top candidates after final scoring.")
+        
+        await r2_service_global.save_candidates_data_async(
+            candidates_data=top_candidates,
+            reanalysis_data={"strategy_used": strategy_decision, "market_conditions": market_context}
+        )
+        
+        if not top_candidates:
+            print("❌ No strong candidates left after final filtering.")
+            await r2_service_global.save_system_logs_async({
+                "no_strong_candidates": True, "strategy": strategy_decision['primary_strategy'],
+                "initial_candidates_count": len(high_potential_candidates)
+            })
+            return
+            
+        print("🧠 Getting LLM analysis for top candidates...")
+        
+        for candidate in top_candidates:
+            try:
+                if not await validate_candidate_data_enhanced(candidate):
+                    print(f"⚠️ Skipping {candidate.get('symbol')} due to quality issues")
+                    continue
+                
+                llm_analysis_data = await llm_service_global.get_trading_decision(candidate)
+                
+                if not llm_analysis_data:
+                    print(f"⚠️ LLM analysis failed for {candidate['symbol']}. Moving to next.")
+                    continue
+
+                if llm_analysis_data.get('action') == "HOLD":
+                    print(f"🧠 LLM decided to HOLD on {candidate['symbol']}. Moving to next.")
+                    continue
+                
+                if llm_analysis_data.get('action') in ["BUY", "SELL"]:
+                    # ✅ التحقق النهائي من الاستراتيجية
+                    final_strategy = llm_analysis_data.get('strategy')
+                    candidate_strategy = candidate.get('target_strategy', 'GENERIC')
+                    
+                    # إذا كانت استراتيجية LLM غير صالحة، استخدم استراتيجية المرشح
+                    if not final_strategy or final_strategy == 'unknown' or final_strategy == 'GENERIC':
+                        final_strategy = candidate_strategy
+                        llm_analysis_data['strategy'] = final_strategy
+                        print(f"🔧 تصحيح استراتيجية LLM لـ {candidate['symbol']}: {final_strategy}")
+                    
+                    print(f"🎯 الاستراتيجية النهائية: {final_strategy}")
+                    
+                    print("\n========================================================")
+                    print(f"💎💎💎 New Trading Opportunity Identified! 💎💎💎")
+                    print(f"   Symbol: {candidate['symbol']}")
+                    print(f"   Action: {llm_analysis_data.get('action')}")
+                    print(f"   Strategy: {final_strategy}")
+                    print(f"   Reasoning: {llm_analysis_data.get('reasoning')}")
+                    print(f"   Confidence: {llm_analysis_data.get('confidence_level')}")
+                    print("========================================================\n")
+                    
+                    await r2_service_global.save_system_logs_async({
+                        "new_opportunity_found": True, "symbol": candidate['symbol'],
+                        "action": llm_analysis_data.get('action'), "strategy": final_strategy,
+                        "confidence": llm_analysis_data.get('confidence_level', 0)
+                    })
+                    
+                    return {
+                        "symbol": candidate['symbol'],
+                        "decision": llm_analysis_data,
+                        "current_price": candidate['current_price'],
+                        "strategy": final_strategy
+                    }
+                    
+            except Exception as error:
+                print(f"❌ LLM/Fallback error for {candidate.get('symbol', 'unknown')}: {error}")
+                traceback.print_exc()
+        
+        print("✅ Cycle finished. No actionable BUY/SELL opportunities found by LLM.")
+        return None
+        
+    except Exception as error:
+        print(f"❌ An error occurred while scanning for opportunities: {error}")
+        traceback.print_exc()
+        await r2_service_global.save_system_logs_async({"opportunity_scan_error": True, "error": str(error)})
+        return None
+
+async def re_analyze_open_trade_async(trade_data):
+    """Re-analyzes an open trade with enhanced strategy preservation"""
+    symbol = trade_data.get('symbol')
+    
+    try:
+        entry_time = datetime.fromisoformat(trade_data['entry_timestamp'])
+        current_time = datetime.now()
+        hold_minutes = (current_time - entry_time).total_seconds() / 60
+        
+        print(f"⏳ Re-analyzing trade: {symbol} (held for {hold_minutes:.1f} minutes)")
+        
+        # ✅ الإصلاح المحسن: الحفاظ على الاستراتيجية الأصلية مع التحقق الشامل
+        original_strategy = trade_data.get('strategy')
+        if not original_strategy or original_strategy == 'unknown':
+            original_strategy = trade_data.get('decision_data', {}).get('strategy', 'GENERIC')
+            print(f"🔧 Fixed original strategy for {symbol}: {original_strategy}")
+        
+        reanalysis_context = {
+            'trade_data': {
+                'symbol': trade_data.get('symbol'),
+                'entry_price': trade_data.get('entry_price'),
+                'entry_time': trade_data.get('entry_timestamp'),
+                'hold_minutes': hold_minutes,
+                'strategy': original_strategy
+            }
+        }
+        
+        try:
+            market_context = await data_manager_global.get_market_context_async()
+        except Exception as error:
+            print(f"⚠️ Failed to get market context: {error}. Using basic market data...")
+            market_context = {'btc_sentiment': 'NEUTRAL'}
+
+        symbol_with_reasons = [{'symbol': symbol, 'reasons': ['re-analysis']}]
+        
+        ohlcv_data_list = await data_manager_global.get_fast_pass_data_async(symbol_with_reasons)
+        if not ohlcv_data_list:
+            print(f"❌ Failed to fetch latest data for {symbol}.")
+            return None
+        
+        raw_data = ohlcv_data_list[0]
+        # ✅ تحديث market_context قبل المعالجة
+        try:
+            updated_market_context = await data_manager_global.get_market_context_async()
+            if updated_market_context:
+                market_context = updated_market_context
+        except Exception as e:
+            print(f"⚠️ Failed to update market context for re-analysis: {e}")
+            
+        feature_processor = FeatureProcessor(market_context, data_manager_global, learning_engine_global)
+        processed_data = await feature_processor.process_and_score_symbol(raw_data)
+        
+        if not processed_data:
+            print(f"❌ Failed to process latest data for {symbol}.")
+            return None
+
+        await r2_service_global.save_candidates_data_async(
+            candidates_data=None,
+            reanalysis_data={'market_context': market_context, 'processed_data': processed_data}
+        )
+
+        print(f"🧠 Getting LLM re-analysis for {symbol}...")
+        try:
+            re_analysis_decision = await llm_service_global.re_analyze_trade_async(trade_data, processed_data)
+            source = re_analysis_decision.get('model_source', 'LLM')
+        except Exception as error:
+            print(f"❌ LLM re-analysis error: {error}. Falling back to local.")
+            re_analysis_decision = local_re_analyze_trade(trade_data, processed_data)
+            source = 'local_fallback'
+        
+        final_decision = _apply_patience_logic(re_analysis_decision, hold_minutes, trade_data, processed_data)
+        
+        # ✅ الإصلاح النهائي: التأكد من وجود الاستراتيجية في القرار النهائي
+        if not final_decision.get('strategy') or final_decision['strategy'] == 'unknown':
+            final_decision['strategy'] = original_strategy
+            print(f"🔧 Final re-analysis strategy fix for {symbol}: {original_strategy}")
+        
+        print(f"✅ Re-analysis decision for {symbol}: {final_decision.get('action')}. Strategy: {final_decision.get('strategy')}. Source: {source}")
+        
+        await r2_service_global.save_system_logs_async({
+            "trade_reanalyzed": True, "symbol": symbol, "action": final_decision.get('action'),
+            "hold_minutes": hold_minutes, "source": source, "strategy": final_decision.get('strategy')
+        })
+        
+        return {
+            "symbol": symbol, "decision": final_decision,
+            "current_price": processed_data.get('current_price'), "hold_minutes": hold_minutes
+        }
+        
+    except Exception as error:
+        print(f"❌ An error occurred during trade re-analysis: {error}")
+        traceback.print_exc()
+        await r2_service_global.save_system_logs_async({"reanalysis_error": True, "symbol": symbol, "error": str(error)})
+        return None
+
+def _apply_patience_logic(decision, hold_minutes, trade_data, processed_data):
+    """Apply patience logic to prevent premature selling decisions"""
+    action = decision.get('action')
+    
+    if action == "CLOSE_TRADE" and hold_minutes < 20:
+        current_price = processed_data.get('current_price', 0)
+        entry_price = trade_data.get('entry_price', 0)
+        
+        try:
+            profit_loss_percent = ((current_price - entry_price) / entry_price) * 100
+        except (TypeError, ZeroDivisionError):
+            profit_loss_percent = 0
+        
+        if profit_loss_percent < 2:
+            print(f"🛑 Blocked premature selling! Only {hold_minutes:.1f} minutes held, PnL: {profit_loss_percent:.2f}%")
+            decision['action'] = "HOLD"
+            decision['reasoning'] = f"Patience Filter: Blocked premature sell. Held for {hold_minutes:.1f}m. Giving trade more time."
+            return decision
+    
+    return decision
+        
+async def run_bot_cycle_async():
+    """The main asynchronous bot cycle with enhanced strategy validation"""
+    print(f"\n{'='*70}")
+    print(f"⏳ New cycle initiated at: {datetime.now().isoformat()}")
+    print(f"{'='*70}")
+    
+    try:
+        await r2_service_global.save_system_logs_async({"cycle_started": True})
+
+        if not r2_service_global.acquire_lock():
+            print("❌ Failed to acquire lock. Skipping cycle.")
+            return
+
+        open_trades = []
+        try:
+            open_trades = await r2_service_global.get_open_trades_async()
+            print(f"✅ Found {len(open_trades)} open trade(s).")
+            
+            # ✅ الإصلاح المحسن: فحص وإصلاح الاستراتيجيات الفارغة في الصفقات المفتوحة
+            trades_fixed = 0
+            for trade in open_trades:
+                if not trade.get('strategy') or trade['strategy'] == 'unknown':
+                    original_strategy = trade.get('decision_data', {}).get('strategy', 'GENERIC')
+                    trade['strategy'] = original_strategy
+                    trades_fixed += 1
+                    print(f"🔧 Fixed missing strategy for {trade['symbol']}: {trade['strategy']}")
+            
+            if trades_fixed > 0:
+                print(f"✅ Fixed strategies for {trades_fixed} trades.")
+                await r2_service_global.save_open_trades_async(open_trades)
+            
+            should_look_for_new_trade = not open_trades
+
+            if open_trades:
+                now = datetime.now()
+                trades_to_reanalyze = [
+                    trade for trade in open_trades 
+                    if now >= datetime.fromisoformat(trade.get('expected_target_time', now.isoformat()))
+                ]
+
+                if trades_to_reanalyze:
+                    print(f"🔍 Re-analyzing {len(trades_to_reanalyze)} trade(s)...")
+                    for trade in trades_to_reanalyze:
+                        result = await re_analyze_open_trade_async(trade)
+                        if result and result['decision'].get('action') == "CLOSE_TRADE":
+                            await r2_service_global.close_trade_async(trade, result['current_price'])
+                            print(f"✅ Trade for {trade['symbol']} CLOSED. Strategy: {trade.get('strategy', 'unknown')}")
+                            if learning_engine_global and learning_engine_global.initialized:
+                                trade_with_strategy = trade.copy()
+                                strategy = result['decision'].get('strategy', trade.get('strategy', 'GENERIC'))
+                                trade_with_strategy['strategy'] = strategy
+                                await learning_engine_global.analyze_trade_outcome(trade_with_strategy, 'CLOSED_BY_REANALYSIS')
+                            should_look_for_new_trade = True
+                        elif result and result['decision'].get('action') == "UPDATE_TRADE":
+                            await r2_service_global.update_trade_async(trade, result['decision'])
+                            print(f"✅ Trade for {trade['symbol']} UPDATED. Strategy: {trade.get('strategy', 'unknown')}")
+                        else:
+                            print(f"✅ Trade for {trade['symbol']} is on HOLD. Strategy: {trade.get('strategy', 'unknown')}")
+                else:
+                    print("✅ No trades due for re-analysis yet.")
+
+            if should_look_for_new_trade:
+                portfolio_state = await r2_service_global.get_portfolio_state_async()
+                if portfolio_state.get("current_capital_usd", 0) > 1:
+                    print(f"✅ Capital available (${portfolio_state['current_capital_usd']:.2f}). Scanning...")
+                    new_opportunity = await find_new_opportunities_async()
+                    if new_opportunity:
+                        print(f"✅ Opportunity for {new_opportunity['symbol']} confirmed! Saving trade. Strategy: {new_opportunity.get('strategy')}")
+                        
+                        # ✅ التحقق النهائي قبل الحفظ
+                        if not new_opportunity['decision'].get('strategy'):
+                            new_opportunity['decision']['strategy'] = new_opportunity.get('strategy', 'GENERIC')
+                            print(f"🔧 Final pre-save strategy fix: {new_opportunity['decision']['strategy']}")
+                        
+                        await r2_service_global.save_new_trade_async(
+                            new_opportunity['symbol'], 
+                            new_opportunity['decision'], 
+                            new_opportunity['current_price']
+                        )
+                        newly_opened_trades = await r2_service_global.get_open_trades_async()
+                        for trade in newly_opened_trades:
+                            if trade['symbol'] == new_opportunity['symbol']:
+                                asyncio.create_task(realtime_monitor._monitor_single_trade(trade))
+                                break
+                    else:
+                        print("✅ Scan complete. No actionable opportunities identified.")
+                else:
+                    print("😴 No available capital. Waiting for current trade to close.")
+            
+        finally:
+            print("✅ Cycle finished. Releasing lock.")
+            r2_service_global.release_lock()
+            await r2_service_global.save_system_logs_async({"cycle_completed": True, "open_trades": len(open_trades)})
+
+    except Exception as error:
+        print(f"❌ Unhandled error in main cycle: {error}")
+        traceback.print_exc()
+        await r2_service_global.save_system_logs_async({"cycle_error": True, "error": str(error)})
+        if r2_service_global.lock_acquired:
+            r2_service_global.release_lock()
+
+@asynccontextmanager
+async def lifespan(application: FastAPI):
+    global r2_service_global, data_manager_global, llm_service_global, learning_engine_global, realtime_monitor
+    print("===== Application Startup =====")
+    
+    try:
+        r2_service_global = R2Service()
+        llm_service_global = LLMService()
+        contracts_database = await r2_service_global.load_contracts_db_async()
+        
+        data_manager_global = DataManager(contracts_database)
+        await data_manager_global.initialize()
+
+        # ✅ تهيئة نظام التعلم مع تمرير data_manager
+        learning_engine_global = LearningEngine(r2_service_global, data_manager_global)
+        await learning_engine_global.initialize_enhanced()  # ✅ استخدام التهيئة المحسنة
+        
+        # ✅ إجبار تحديث الاستراتيجيات من البيانات الحالية
+        await learning_engine_global.force_strategy_learning()
+        
+        # ✅ التحقق من أن الأوزان يتم تحميلها
+        if learning_engine_global.initialized:
+            weights = await learning_engine_global.get_optimized_strategy_weights("bull_market")
+            print(f"🎯 الأوزان المحملة: {weights}")
+        
+        realtime_monitor = RealTimeTradeMonitor()
+        
+        asyncio.create_task(monitor_market_async())
+        asyncio.create_task(realtime_monitor.start_monitoring())
+        
+        await r2_service_global.save_system_logs_async({"application_started": True})
+        
+        print("\n✅ All services initialized. Application is ready.\n")
+        yield
+        
+    except Exception as error:
+        print(f"❌ Application startup failed: {error}")
+        traceback.print_exc()
+        if r2_service_global:
+            await r2_service_global.save_system_logs_async({"application_startup_failed": True, "error": str(error)})
+        raise
+    finally:
+        await cleanup_on_shutdown()
+
+application = FastAPI(lifespan=lifespan)
+
+@application.get("/run-cycle")
+async def run_cycle_api():
+    """API endpoint to trigger the bot cycle."""
+    asyncio.create_task(run_bot_cycle_async())
+    return {"message": "Bot cycle initiated in the background."}
+
+@application.get("/health")
+async def health_check():
+    """Detailed health check."""
+    learning_metrics = {}
+    if learning_engine_global and learning_engine_global.initialized:
+        learning_metrics = await learning_engine_global.calculate_performance_metrics()
+    
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "services": {
+            "r2_service": "initialized" if r2_service_global else "uninitialized",
+            "llm_service": "initialized" if llm_service_global else "uninitialized",
+            "data_manager": "initialized" if data_manager_global else "uninitialized",
+            "learning_engine": "active" if learning_engine_global and learning_engine_global.initialized else "inactive",
+            "realtime_monitor": "running" if realtime_monitor and realtime_monitor.is_running else "stopped"
+        },
+        "market_state_ok": state.MARKET_STATE_OK,
+        "learning_engine": learning_metrics
+    }
+
+@application.get("/stats")
+async def get_performance_stats():
+    """Get performance statistics for all services."""
+    try:
+        market_context = await data_manager_global.get_market_context_async() if data_manager_global else {}
+        
+        learning_stats = {}
+        improvement_suggestions = []
+        if learning_engine_global and learning_engine_global.initialized:
+            learning_stats = await learning_engine_global.calculate_performance_metrics()
+            improvement_suggestions = await learning_engine_global.suggest_improvements()
+        
+        stats = {
+            "timestamp": datetime.now().isoformat(),
+            "data_manager": data_manager_global.get_performance_stats() if data_manager_global else {},
+            "market_state": {
+                "is_healthy": state.MARKET_STATE_OK,
+                "description": "Market is healthy for trading" if state.MARKET_STATE_OK else "Market conditions are unfavorable",
+                "context": market_context
+            },
+            "realtime_monitoring": {
+                "active_trades": len(realtime_monitor.monitoring_tasks) if realtime_monitor else 0,
+                "is_running": realtime_monitor.is_running if realtime_monitor else False
+            },
+            "learning_engine": learning_stats,
+            "improvement_suggestions": improvement_suggestions
+        }
+        return stats
+    except Exception as error:
+        raise HTTPException(status_code=500, detail=f"Failed to retrieve stats: {str(error)}")
+
+@application.get("/logs/status")
+async def get_logs_status():
+    """Get status of logging system."""
+    try:
+        open_trades = await r2_service_global.get_open_trades_async()
+        portfolio_state = await r2_service_global.get_portfolio_state_async()
+        
+        return {
+            "logging_system": "active",
+            "open_trades_count": len(open_trades),
+            "current_capital": portfolio_state.get("current_capital_usd", 0),
+            "total_trades": portfolio_state.get("total_trades", 0),
+            "timestamp": datetime.now().isoformat()
+        }
+    except Exception as error:
+        raise HTTPException(status_code=500, detail=f"Failed to get logs status: {str(error)}")
+
+async def cleanup_on_shutdown():
+    """Cleanup function for graceful shutdown."""
+    global r2_service_global, data_manager_global, realtime_monitor, learning_engine_global
+    print("\n🛑 Shutdown signal received. Cleaning up...")
+    
+    if r2_service_global:
+        try:
+            await r2_service_global.save_system_logs_async({"application_shutdown": True})
+        except Exception as log_error:
+            print(f"⚠️ Failed to save shutdown log: {log_error}")
+    
+    if learning_engine_global and learning_engine_global.initialized:
+        try:
+            await learning_engine_global.save_weights_to_r2()
+            await learning_engine_global.save_performance_history()
+            print("✅ Learning engine data saved.")
+        except Exception as e:
+            print(f"⚠️ Failed to save learning engine data: {e}")
+    
+    if realtime_monitor:
+        realtime_monitor.stop_monitoring()
+    
+    if r2_service_global and r2_service_global.lock_acquired:
+        r2_service_global.release_lock()
+        print("✅ Lock released.")
+    if data_manager_global:
+        await data_manager_global.close()
+    print("✅ Cleanup completed.")
+
+def signal_handler(signum, frame):
+    """Handle shutdown signals."""
+    print(f"\n⚠️ Received signal {signum}")
+    asyncio.create_task(cleanup_on_shutdown())
+    sys.exit(0)
+
+signal.signal(signal.SIGINT, signal_handler)
+signal.signal(signal.SIGTERM, signal_handler)
+
+if __name__ == "__main__":
+    uvicorn.run(application, host="0.0.0.0", port=7860)

data_manager (23).py

@@ -0,0 +1,1431 @@
+# data_manager_fixed.py - الإصدار النهائي مع إصلاح الأخطاء الحرجة
+import os, asyncio, httpx, json, traceback, backoff, re, time, hashlib
+from datetime import datetime, timedelta
+from functools import wraps
+import ccxt.pro as ccxt
+from ccxt.base.errors import RateLimitExceeded, DDoSProtection, NetworkError
+import pandas as pd
+import numpy as np
+from state import MARKET_STATE_OK
+
+# --- 🐋 نظام مراقبة الحيتان العام مع مصادر مؤكدة ---
+class ReliableWhaleMonitor:
+    def __init__(self, contracts_db=None):
+        self._http_client = None
+        self.contracts_db = contracts_db or {}
+        
+        self.whale_threshold_usd = 50000
+        self.token_whale_threshold_usd = 25000
+        
+        # ✅ مصادر بيانات مؤكدة وعاملة 100%
+        self.reliable_data_sources = {
+            'coin_gecko': 'https://api.coingecko.com/api/v3',
+            'dex_screener': 'https://api.dexscreener.com/latest/dex',
+            'fear_greed': 'https://api.alternative.me/fng/',
+            'binance_api': 'https://api.binance.com/api/v3',
+            'bybit_api': 'https://api.bybit.com/v2/public'
+        }
+        
+        # ✅ RPC endpoints لكل الشبكات الرئيسية
+        self.rpc_endpoints = {
+            'ethereum': [
+                'https://eth-mainnet.public.blastapi.io',
+                'https://rpc.ankr.com/eth',
+                'https://cloudflare-eth.com'
+            ],
+            'bsc': [
+                'https://bsc-dataseed.binance.org/',
+                'https://bsc-dataseed1.defibit.io/',
+                'https://bsc-dataseed1.ninicoin.io/'
+            ],
+            'polygon': [
+                'https://polygon-rpc.com/',
+                'https://rpc-mainnet.maticvigil.com/',
+                'https://rpc.ankr.com/polygon'
+            ],
+            'arbitrum': [
+                'https://arb1.arbitrum.io/rpc',
+                'https://arbitrum.public-rpc.com'
+            ],
+            'optimism': [
+                'https://mainnet.optimism.io',
+                'https://optimism.public-rpc.com'
+            ],
+            'avalanche': [
+                'https://api.avax.network/ext/bc/C/rpc',
+                'https://avalanche.public-rpc.com'
+            ],
+            'fantom': [
+                'https://rpc.ftm.tools/',
+                'https://fantom.public-rpc.com'
+            ],
+            'base': [
+                'https://mainnet.base.org',
+                'https://base.public-rpc.com'
+            ]
+        }
+        
+        self.current_rpc_index = {network: 0 for network in self.rpc_endpoints.keys()}
+        
+        # ✅ عناوين التبادلات الرئيسية للمراقبة
+        self.major_exchanges = {
+            'binance': [
+                '0x3f5ce5fbfe3e9af3971dd833d26ba9b5c936f0be',
+                '0xd551234ae421e3bcba99a0da6d736074f22192ff',
+                '0x564286362092d8e7936f0549571a803b203aaced'
+            ],
+            'coinbase': [
+                '0xa910f92acdaf488fa6ef02174fb86208ad7722ba',
+                '0x4fabb145d64652a948d72533023f6e7a623c7c53'
+            ],
+            'kraken': [
+                '0x2910543af39aba0cd09dbb2d50200b3e800a63d2',
+                '0x689c56aef474df92d44a1b70850f808488f9769c'
+            ]
+        }
+        
+        self.price_cache = {}
+        self.volume_cache = {}
+        self.whale_activity_cache = {}
+
+    @property
+    def http_client(self):
+        if self._http_client is None:
+            self._http_client = httpx.AsyncClient(timeout=20.0)
+        return self._http_client
+
+    async def close(self):
+        """إغلاق جميع العملاء بشكل آمن"""
+        if self._http_client:
+            await self._http_client.aclose()
+            self._http_client = None
+
+    async def _get_working_rpc(self, network):
+        """الحصول على RPC عامل للشبكة المطلوبة"""
+        if network not in self.rpc_endpoints:
+            return None
+            
+        endpoints = self.rpc_endpoints[network]
+        start_index = self.current_rpc_index[network]
+        
+        for i in range(len(endpoints)):
+            index = (start_index + i) % len(endpoints)
+            endpoint = endpoints[index]
+            
+            try:
+                # اختبار اتصال RPC
+                payload = {
+                    "jsonrpc": "2.0",
+                    "method": "eth_blockNumber",
+                    "params": [],
+                    "id": 1
+                }
+                    
+                async with httpx.AsyncClient(timeout=10) as client:
+                    response = await client.post(endpoint, json=payload)
+                    if response.status_code == 200:
+                        self.current_rpc_index[network] = index
+                        return endpoint
+            except Exception:
+                continue
+                
+        return None
+
+    async def _get_token_contract_from_coingecko(self, symbol):
+        """جلب عقد العملة من CoinGecko"""
+        try:
+            url = f"https://api.coingecko.com/api/v3/coins/{symbol.lower()}"
+            async with httpx.AsyncClient(timeout=10) as client:
+                response = await client.get(url)
+                if response.status_code == 200:
+                    data = response.json()
+                    platforms = data.get('platforms', {})
+                    
+                    # إرجاع كل المنصات المتاحة
+                    contract_info = {}
+                    for platform, address in platforms.items():
+                        if address and address != "":
+                            # تحويل أسماء المنصات إلى أسماء شبكات قياسية
+                            network_map = {
+                                'ethereum': 'ethereum',
+                                'binance-smart-chain': 'bsc',
+                                'polygon-pos': 'polygon',
+                                'arbitrum-one': 'arbitrum',
+                                'optimistic-ethereum': 'optimism',
+                                'avalanche': 'avalanche',
+                                'fantom': 'fantom',
+                                'base': 'base'
+                            }
+                            network = network_map.get(platform, platform)
+                            contract_info[network] = {
+                                'address': address,
+                                'network': network,
+                                'symbol': symbol.upper(),
+                                'name': data.get('name', ''),
+                                'coingecko_id': data.get('id', '')
+                            }
+                    
+                    return contract_info if contract_info else None
+                    
+        except Exception as e:
+            print(f"⚠️ فشل جلب عقد {symbol} من CoinGecko: {e}")
+        
+        return None
+
+    async def _get_reliable_price(self, coin_id):
+        """جلب سعر موثوق من CoinGecko"""
+        now = time.time()
+        cache_key = f"price_{coin_id}"
+        
+        if cache_key in self.price_cache and (now - self.price_cache[cache_key]['timestamp']) < 300:
+            return self.price_cache[cache_key]['price']
+
+        try:
+            url = f"https://api.coingecko.com/api/v3/simple/price?ids={coin_id}&vs_currencies=usd"
+            async with httpx.AsyncClient(timeout=10) as client:
+                response = await client.get(url)
+                if response.status_code == 200:
+                    data = response.json()
+                    price = data.get(coin_id, {}).get('usd')
+                    if price and price > 0:
+                        self.price_cache[cache_key] = {'price': price, 'timestamp': now}
+                        return price
+                elif response.status_code == 429:
+                    print("⚠️ CoinGecko rate limit reached, using fallback")
+                    return None
+        except Exception as e:
+            print(f"⚠️ فشل جلب سعر {coin_id}: {e}")
+        
+        return None
+
+    async def _get_btc_price(self):
+        """جلب سعر البيتكوين"""
+        return await self._get_reliable_price('bitcoin')
+
+    async def _get_eth_price(self):
+        """جلب سعر الإيثيريوم"""
+        return await self._get_reliable_price('ethereum')
+
+    async def _get_top_crypto_volumes(self):
+        """جلب أحجام التداول للعملات الرائدة من CoinGecko"""
+        try:
+            url = "https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&order=volume_desc&per_page=20&page=1&sparkline=false"
+            async with httpx.AsyncClient(timeout=10) as client:
+                response = await client.get(url)
+                if response.status_code == 200:
+                    coins = response.json()
+                    
+                    volume_data = []
+                    for coin in coins:
+                        if isinstance(coin, dict):  # ✅ التحقق من النوع
+                            volume_data.append({
+                                'symbol': coin.get('symbol', '').upper(),
+                                'name': coin.get('name', ''),
+                                'volume_24h': coin.get('total_volume', 0),
+                                'price': coin.get('current_price', 0),
+                                'price_change_24h': coin.get('price_change_percentage_24h', 0)
+                            })
+                    
+                    return volume_data
+                elif response.status_code == 429:
+                    print("⚠️ CoinGecko rate limit reached for volumes")
+                    return []  # إرجاع قائمة فارغة بدلاً من None
+                else:
+                    print(f"⚠️ CoinGecko returned status {response.status_code}")
+                    return []  # ✅ إرجاع قائمة فارغة بدلاً من None
+                
+        except Exception as e:
+            print(f"⚠️ فشل جلب أحجام التداول: {e}")
+            return []  # ✅ إرجاع قائمة فارغة بدلاً من None
+
+    async def _get_dex_screener_data(self, token_address=None):
+        """جلب بيانات DEX من DexScreener (مصدر موثوق)"""
+        try:
+            if token_address:
+                url = f"https://api.dexscreener.com/latest/dex/tokens/{token_address}"
+            else:
+                url = "https://api.dexscreener.com/latest/dex/search?q=ETH"
+            
+            async with httpx.AsyncClient(timeout=15) as client:
+                response = await client.get(url)
+                if response.status_code == 200:
+                    return response.json()
+        except Exception as e:
+            print(f"⚠️ فشل جلب بيانات DexScreener: {e}")
+        
+        return None
+
+    async def _analyze_dex_whale_activity(self):
+        """تحليل نشاط الحيتان على DEXs باستخدام DexScreener"""
+        print("🔍 تحليل نشاط الحيتان على DEXs...")
+        
+        whale_activity = []
+        
+        try:
+            # الحصول على بيانات ETH كمرجع رئيسي
+            eth_data = await self._get_dex_screener_data("0x2170ed0880ac9a755fd29b2688956bd959f933f8")
+            
+            if eth_data and 'pairs' in eth_data:
+                for pair in eth_data['pairs'][:15]:  # أول 15 زوج
+                    try:
+                        volume_24h = float(pair.get('volume', {}).get('h24', 0))
+                        liquidity = float(pair.get('liquidity', {}).get('usd', 0))
+                        
+                        # اعتبار التداولات الكبيرة كحركات حيتان
+                        if volume_24h >= self.whale_threshold_usd:
+                            whale_activity.append({
+                                'protocol': 'DEX',
+                                'symbol': pair.get('baseToken', {}).get('symbol', 'UNKNOWN'),
+                                'volume_usd': volume_24h,
+                                'liquidity_usd': liquidity,
+                                'price': float(pair.get('priceUsd', 0)),
+                                'exchange': pair.get('dexId', 'UNKNOWN'),
+                                'price_change_24h': float(pair.get('priceChange', {}).get('h24', 0))
+                            })
+                    except (ValueError, TypeError) as e:
+                        continue
+                        
+            print(f"✅ تم تحليل {len(whale_activity)} حركة على DEXs")
+            
+        except Exception as e:
+            print(f"❌ خطأ في تحليل DEXs: {e}")
+        
+        return whale_activity
+
+    async def _analyze_cex_whale_activity(self):
+        """تحليل نشاط الحيتان على التبادلات المركزية باستخدام CCXT"""
+        print("🏦 تحليل نشاط الحيتان على CEXs...")
+        
+        whale_activity = []
+        
+        try:
+            # استخدام KuCoin كمثال (يعمل بدون API key للبيانات العامة)
+            exchange = ccxt.kucoin()
+            markets = await exchange.fetch_markets()
+            
+            # تحليل أكبر 20 سوق من حيث الحجم
+            for market in markets[:20]:
+                try:
+                    symbol = market['symbol']
+                    if '/USDT' in symbol or '/BTC' in symbol:
+                        ticker = await exchange.fetch_ticker(symbol)
+                        volume_24h = ticker.get('quoteVolume', 0)
+                        
+                        if volume_24h >= self.whale_threshold_usd:
+                            whale_activity.append({
+                                'protocol': 'CEX',
+                                'symbol': symbol,
+                                'volume_usd': volume_24h,
+                                'price': ticker.get('last', 0),
+                                'price_change_24h': ticker.get('percentage', 0),
+                                'exchange': 'kucoin'
+                            })
+                except Exception:
+                    continue
+            
+            print(f"✅ تم تحليل {len(whale_activity)} حركة على CEXs")
+            
+        except Exception as e:
+            print(f"⚠️ فشل تحليل CEXs: {e}")
+        
+        return whale_activity
+
+    async def _get_market_sentiment_analysis(self):
+        """تحليل مشاعر السوق بناءً على بيانات متعددة"""
+        print("🎭 تحليل مشاعر السوق...")
+        
+        try:
+            # مؤشر الخوف والجشع
+            async with httpx.AsyncClient(timeout=10) as client:
+                response = await client.get("https://api.alternative.me/fng/")
+                if response.status_code == 200:
+                    data = response.json()
+                    fear_greed = int(data['data'][0]['value'])
+                    fear_greed_class = data['data'][0]['value_classification']
+                else:
+                    fear_greed = 50
+                    fear_greed_class = "Neutral"
+            
+            # اتجاه السوق بناءً على سعر البيتكوين
+            btc_price = await self._get_btc_price()
+            if btc_price:
+                if btc_price > 60000:
+                    market_trend = "BULLISH"
+                elif btc_price < 55000:
+                    market_trend = "BEARISH" 
+                else:
+                    market_trend = "NEUTRAL"
+            else:
+                market_trend = "NEUTRAL"
+            
+            return {
+                'fear_greed_index': fear_greed,
+                'fear_greed_class': fear_greed_class,
+                'market_trend': market_trend,
+                'btc_price': btc_price
+            }
+            
+        except Exception as e:
+            print(f"⚠️ فشل تحليل المشاعر: {e}")
+            return {
+                'fear_greed_index': 50,
+                'fear_greed_class': "Neutral", 
+                'market_trend': "NEUTRAL",
+                'btc_price': None
+            }
+
+    async def get_comprehensive_whale_analysis(self):
+        """تحليل شامل للحيتان باستخدام مصادر موثوقة"""
+        print("🐋 بدء التحليل الشامل للحيتان...")
+        
+        try:
+            # ✅ تشغيل جميع التحليلات بالتوازي
+            dex_task = self._analyze_dex_whale_activity()
+            cex_task = self._analyze_cex_whale_activity()
+            sentiment_task = self._get_market_sentiment_analysis()
+            volumes_task = self._get_top_crypto_volumes()
+            
+            results = await asyncio.gather(
+                dex_task, cex_task, sentiment_task, volumes_task,
+                return_exceptions=True
+            )
+            
+            # ✅ معالجة النتائج
+            dex_whales = results[0] if not isinstance(results[0], Exception) else []
+            cex_whales = results[1] if not isinstance(results[1], Exception) else []
+            sentiment = results[2] if not isinstance(results[2], Exception) else {}
+            top_volumes = results[3] if not isinstance(results[3], Exception) else []
+            
+            # ✅ دمج جميع البيانات
+            all_whale_activity = dex_whales + cex_whales
+            
+            # ✅ حساب الإحصائيات
+            total_volume = sum(activity.get('volume_usd', 0) for activity in all_whale_activity)
+            total_transactions = len(all_whale_activity)
+            
+            # ✅ تحليل أحجام العملات الرائدة
+            high_volume_coins = [coin for coin in top_volumes if coin.get('volume_24h', 0) > 100000000]  # 100M+
+            
+            # ✅ حساب التأثير الشامل
+            overall_impact = self._calculate_overall_impact(
+                total_volume, total_transactions, len(high_volume_coins), sentiment
+            )
+            
+            # ✅ تحليل النوايا
+            intent_analysis = self._analyze_trading_intents(all_whale_activity, top_volumes)
+            
+            # ✅ إنشاء التقرير
+            description = self._generate_comprehensive_description(
+                overall_impact, total_volume, total_transactions, 
+                len(high_volume_coins), intent_analysis, sentiment
+            )
+            
+            print(f"📊 التحليل الشامل: {overall_impact}")
+            print(f"💰 الحجم الإجمالي: ${total_volume:,.0f}")
+            print(f"🔢 عدد المعاملات: {total_transactions}")
+            print(f"🎯 العملات عالية الحجم: {len(high_volume_coins)}")
+            
+            return {
+                'overall_impact': overall_impact,
+                'total_volume_usd': total_volume,
+                'total_transactions': total_transactions,
+                'description': description,
+                'high_volume_coins_count': len(high_volume_coins),
+                'whale_activity': all_whale_activity[:10],  # أهم 10 حركة
+                'market_sentiment': sentiment,
+                'trading_intents': intent_analysis,
+                'timestamp': datetime.now().isoformat(),
+                'data_available': len(all_whale_activity) > 0,
+                'data_sources': ['coin_gecko', 'dex_screener', 'kucoin_api', 'fear_greed']
+            }
+            
+        except Exception as e:
+            print(f"❌ فشل التحليل الشامل: {e}")
+            traceback.print_exc()
+            return self._get_fallback_analysis()
+
+    def _calculate_overall_impact(self, total_volume, total_transactions, high_volume_coins_count, sentiment):
+        """حساب التأثير الشامل"""
+        if total_volume == 0 and total_transactions == 0:
+            return 'LOW'
+        
+        # ✅ تحليل الحجم
+        volume_score = 0
+        if total_volume > 10000000:
+            volume_score = 4
+        elif total_volume > 5000000:
+            volume_score = 3
+        elif total_volume > 1000000:
+            volume_score = 2
+        elif total_volume > 500000:
+            volume_score = 1
+        
+        # ✅ تحليل النشاط
+        activity_score = 0
+        if total_transactions > 15:
+            activity_score = 3
+        elif total_transactions > 8:
+            activity_score = 2
+        elif total_transactions > 3:
+            activity_score = 1
+        
+        # ✅ تحليل العملات عالية الحجم
+        volume_coins_score = min(high_volume_coins_count, 3)
+        
+        # ✅ تحليل المشاعر
+        sentiment_score = 0
+        market_trend = sentiment.get('market_trend', 'NEUTRAL')
+        if market_trend == 'BULLISH':
+            sentiment_score = 1
+        elif market_trend == 'BEARISH':
+            sentiment_score = -1
+        
+        total_score = volume_score + activity_score + volume_coins_score + sentiment_score
+        
+        if total_score >= 6:
+            return 'HIGH'
+        elif total_score >= 3:
+            return 'MEDIUM'
+        else:
+            return 'LOW'
+
+    def _analyze_trading_intents(self, whale_activity, top_volumes):
+        """تحليل نوايا التداول"""
+        try:
+            # تحليل اتجاهات الأسعار في الحركات الكبيرة
+            bullish_count = 0
+            bearish_count = 0
+            
+            for activity in whale_activity:
+                price_change = activity.get('price_change_24h', 0)
+                if price_change > 0:
+                    bullish_count += 1
+                elif price_change < 0:
+                    bearish_count += 1
+            
+            # تحليل العملات عالية الحجم
+            volume_bullish = 0
+            volume_bearish = 0
+            
+            for coin in top_volumes[:10]:  # أهم 10 عملة
+                price_change = coin.get('price_change_24h', 0)
+                if price_change > 0:
+                    volume_bullish += 1
+                elif price_change < 0:
+                    volume_bearish += 1
+            
+            total_bullish = bullish_count + volume_bullish
+            total_bearish = bearish_count + volume_bearish
+            
+            if total_bullish > total_bearish:
+                dominant_intent = 'BUY'
+                buy_sell_ratio = total_bullish / max(total_bearish, 1)
+            elif total_bearish > total_bullish:
+                dominant_intent = 'SELL'
+                buy_sell_ratio = total_bullish / max(total_bearish, 1)
+            else:
+                dominant_intent = 'HOLD'
+                buy_sell_ratio = 1.0
+            
+            # تحديد مشاعر السوق
+            if buy_sell_ratio > 1.5:
+                market_sentiment = 'BULLISH'
+            elif buy_sell_ratio > 1.0:
+                market_sentiment = 'SLIGHTLY_BULLISH'
+            elif buy_sell_ratio == 1.0:
+                market_sentiment = 'NEUTRAL'
+            elif buy_sell_ratio > 0.5:
+                market_sentiment = 'SLIGHTLY_BEARISH'
+            else:
+                market_sentiment = 'BEARISH'
+            
+            return {
+                'dominant_intent': dominant_intent,
+                'buy_sell_ratio': buy_sell_ratio,
+                'market_sentiment': market_sentiment,
+                'bullish_signals': total_bullish,
+                'bearish_signals': total_bearish
+            }
+            
+        except Exception as e:
+            print(f"⚠️ خطأ في تحليل النوايا: {e}")
+            return {
+                'dominant_intent': 'UNKNOWN',
+                'buy_sell_ratio': 1.0,
+                'market_sentiment': 'NEUTRAL',
+                'bullish_signals': 0,
+                'bearish_signals': 0
+            }
+
+    def _generate_comprehensive_description(self, overall_impact, total_volume, total_transactions, high_volume_coins_count, intent_analysis, sentiment):
+        """إنشاء وصف شامل"""
+        if overall_impact == 'HIGH':
+            base_desc = "🚨 نشاط تداول عالي الخطورة"
+        elif overall_impact == 'MEDIUM':
+            base_desc = "⚠️ نشاط تداول متوسط"
+        else:
+            base_desc = "✅ نشاط تداول طبيعي"
+        
+        # ✅ إضافة تفاصيل الحجم والنشاط
+        base_desc += f" (حجم: ${total_volume:,.0f}, معاملات: {total_transactions}"
+        
+        if high_volume_coins_count > 0:
+            base_desc += f", عملات عالية الحجم: {high_volume_coins_count}"
+        
+        base_desc += ")"
+        
+        # ✅ إضافة تحليل النوايا
+        dominant_intent = intent_analysis.get('dominant_intent', 'UNKNOWN')
+        market_sentiment = intent_analysis.get('market_sentiment', 'NEUTRAL')
+        
+        if dominant_intent != 'UNKNOWN':
+            base_desc += f" - النوايا: {dominant_intent}"
+        
+        # ✅ إضافة مؤشر المشاعر
+        sentiment_emoji = {
+            'BULLISH': '📈',
+            'SLIGHTLY_BULLISH': '↗️',
+            'NEUTRAL': '➡️',
+            'SLIGHTLY_BEARISH': '↘️',
+            'BEARISH': '📉'
+        }.get(market_sentiment, '➡️')
+        
+        base_desc += f" {sentiment_emoji}"
+        
+        return base_desc
+
+    def _get_fallback_analysis(self):
+        """تحليل احتياطي عند فشل المصادر"""
+        return {
+            'overall_impact': 'LOW',
+            'total_volume_usd': 0,
+            'total_transactions': 0,
+            'description': 'بيانات الحيتان غير متاحة حاليًا',
+            'high_volume_coins_count': 0,
+            'whale_activity': [],
+            'market_sentiment': {
+                'fear_greed_index': 50,
+                'fear_greed_class': 'Neutral',
+                'market_trend': 'NEUTRAL'
+            },
+            'trading_intents': {
+                'dominant_intent': 'UNKNOWN',
+                'buy_sell_ratio': 1.0,
+                'market_sentiment': 'NEUTRAL'
+            },
+            'timestamp': datetime.now().isoformat(),
+            'data_available': False,
+            'data_sources': []
+        }
+
+    async def get_whale_activity_legacy(self):
+        """وظيفة legacy للحفاظ على التوافق"""
+        analysis = await self.get_comprehensive_whale_analysis()
+        
+        sentiment_map = {
+            'BULLISH': 'BULLISH',
+            'SLIGHTLY_BULLISH': 'BULLISH',
+            'NEUTRAL': 'NEUTRAL',
+            'SLIGHTLY_BEARISH': 'BEARISH',
+            'BEARISH': 'BEARISH'
+        }
+        
+        sentiment = sentiment_map.get(
+            analysis['trading_intents'].get('market_sentiment', 'NEUTRAL'),
+            'NEUTRAL'
+        )
+        
+        critical_alert = analysis['overall_impact'] == 'HIGH'
+        
+        return {
+            'data_available': analysis['data_available'],
+            'description': analysis['description'],
+            'critical_alert': critical_alert,
+            'sentiment': sentiment,
+            'total_volume_usd': analysis['total_volume_usd'],
+            'transaction_count': analysis['total_transactions'],
+            'market_impact': analysis['overall_impact'],
+            'buy_sell_ratio': analysis['trading_intents'].get('buy_sell_ratio', 0.5),
+            'whale_intent_analysis': analysis['trading_intents'],
+            'scan_summary': {
+                'data_sources_used': analysis.get('data_sources', []),
+                'high_volume_coins': analysis.get('high_volume_coins_count', 0),
+                'time_range_minutes': 60
+            }
+        }
+
+# --- 🎯 نظام مراقبة الحيتان الخاص بالعملات المحددة ---
+class SpecificWhaleMonitor:
+    """نظام مراقبة الحيتان الخاص بالعملات المحددة"""
+    
+    def __init__(self, contracts_db, general_monitor):
+        self.contracts_db = contracts_db
+        self.general_monitor = general_monitor
+        self.specific_activity_cache = {}
+        
+    async def get_specific_whale_activity(self, symbols):
+        """جلب تحركات الحيتان الخاصة برموز محددة"""
+        specific_activity = {}
+        
+        for symbol in symbols:
+            try:
+                # تنظيف الرمز (إزالة /USDT etc.)
+                clean_symbol = symbol.replace('/USDT', '').replace('/BUSD', '').split('/')[0]
+                
+                # البحث في قاعدة البيانات أولاً
+                contract_info = self.contracts_db.get(clean_symbol.upper())
+                
+                if not contract_info:
+                    # إذا لم يوجد، جلب من CoinGecko
+                    contract_info = await self.general_monitor._get_token_contract_from_coingecko(clean_symbol)
+                    if contract_info:
+                        # حفظ في قاعدة البيانات للمستقبل
+                        self.contracts_db[clean_symbol.upper()] = contract_info
+                
+                if contract_info:
+                    whale_data = await self._analyze_specific_whale_activity(clean_symbol, contract_info)
+                    if whale_data:
+                        specific_activity[symbol] = whale_data
+                        
+            except Exception as e:
+                print(f"⚠️ فشل مراقبة الحيتان الخاصة لـ {symbol}: {e}")
+                continue
+                
+        return specific_activity
+    
+    async def _analyze_specific_whale_activity(self, symbol, contract_info):
+        """ت��ليل تحركات الحيتان لعملة محددة"""
+        try:
+            whale_activity = {
+                'symbol': symbol,
+                'contract_info': contract_info,
+                'large_transactions': [],
+                'dex_activity': [],
+                'total_volume_24h': 0,
+                'whale_transaction_count': 0,
+                'last_updated': datetime.now().isoformat()
+            }
+            
+            # 1. تحليل نشاط DEX للعملة المحددة
+            dex_activity = await self._get_dex_activity_for_token(contract_info)
+            if dex_activity:
+                whale_activity['dex_activity'] = dex_activity
+                whale_activity['total_volume_24h'] = sum(tx.get('volume_usd', 0) for tx in dex_activity)
+                whale_activity['whale_transaction_count'] = len(dex_activity)
+            
+            # 2. تحليل التحركات على الشبكة (إذا كان لدينا عقد)
+            for network, contract_data in contract_info.items():
+                if isinstance(contract_data, dict) and 'address' in contract_data:
+                    network_activity = await self._get_whale_transactions_from_network(
+                        contract_data['address'], network
+                    )
+                    whale_activity['large_transactions'].extend(network_activity)
+            
+            return whale_activity if whale_activity['whale_transaction_count'] > 0 else None
+            
+        except Exception as e:
+            print(f"⚠️ فشل تحليل الحيتان الخاصة لـ {symbol}: {e}")
+            return None
+    
+    async def _get_dex_activity_for_token(self, contract_info):
+        """جلب نشاط DEX للعملة المحددة"""
+        dex_activity = []
+        
+        try:
+            # استخدام أول عقد متاح للبحث في DexScreener
+            for network, contract_data in contract_info.items():
+                if isinstance(contract_data, dict) and 'address' in contract_data:
+                    dex_data = await self.general_monitor._get_dex_screener_data(contract_data['address'])
+                    
+                    if dex_data and 'pairs' in dex_data:
+                        for pair in dex_data['pairs'][:5]:  # أول 5 أزواج فقط
+                            volume_24h = float(pair.get('volume', {}).get('h24', 0))
+                            
+                            if volume_24h >= self.general_monitor.token_whale_threshold_usd:
+                                dex_activity.append({
+                                    'dex': pair.get('dexId', 'UNKNOWN'),
+                                    'pair': pair.get('pairAddress', ''),
+                                    'volume_usd': volume_24h,
+                                    'price': float(pair.get('priceUsd', 0)),
+                                    'price_change_24h': float(pair.get('priceChange', {}).get('h24', 0)),
+                                    'liquidity_usd': float(pair.get('liquidity', {}).get('usd', 0)),
+                                    'network': network
+                                })
+                        break  # استخدام أول شبكة تعمل
+            
+        except Exception as e:
+            print(f"⚠️ فشل جلب نشاط DEX الخاص: {e}")
+            
+        return dex_activity
+
+    async def _get_whale_transactions_from_network(self, contract_address, network):
+        """جلب تحركات الحيتان من الشبكة باستخدام RPC"""
+        try:
+            rpc_url = await self.general_monitor._get_working_rpc(network)
+            if not rpc_url:
+                return []
+                
+            # هنا يمكن إضافة كود لتحليل التحركات الكبيرة من الشبكة
+            # هذا مثال مبسط - في الواقع تحتاج لخدمات متخصصة مثل Moralis, Alchemy, etc.
+            
+            payload = {
+                "jsonrpc": "2.0",
+                "method": "eth_getLogs",
+                "params": [{
+                    "address": contract_address,
+                    "fromBlock": "latest",
+                    "toBlock": "latest",
+                    "topics": [
+                        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"  # Transfer event
+                    ]
+                }],
+                "id": 1
+            }
+            
+            async with httpx.AsyncClient(timeout=15) as client:
+                response = await client.post(rpc_url, json=payload)
+                if response.status_code == 200:
+                    data = response.json()
+                    # معالجة البيانات هنا
+                    return self._process_transfer_events(data.get('result', []), network)
+                    
+        except Exception as e:
+            print(f"⚠️ فشل جلب تحركات من {network}: {e}")
+            
+        return []
+
+    def _process_transfer_events(self, events, network):
+        """معالجة أحداث التحويل لاكتشاف التحركات الكبيرة"""
+        large_transfers = []
+        
+        for event in events[:10]:  # تحليل أول 10 أحداث فقط للأداء
+            try:
+                # استخراج كمية التحويل (هذا مثال مبسط)
+                # في التطبيق الحقيقي تحتاج لتحليل أكثر تعقيداً
+                if 'data' in event and len(event['data']) >= 66:
+                    # تحويل hex إلى قيمة رقمية
+                    value_hex = event['data'][2:66]  # إزالة 0x
+                    value = int(value_hex, 16)
+                    
+                    # اعتبار التحويلات الكبيرة كتحركات حيتان
+                    if value > 1000000000000000000:  # 1 ETH أو ما يعادله
+                        large_transfers.append({
+                            'network': network,
+                            'value': value,
+                            'transaction_hash': event.get('transactionHash', ''),
+                            'from': event.get('topics', [])[1] if len(event.get('topics', [])) > 1 else '',
+                            'to': event.get('topics', [])[2] if len(event.get('topics', [])) > 2 else '',
+                            'timestamp': datetime.now().isoformat()
+                        })
+            except Exception:
+                continue
+                
+        return large_transfers
+
+# إنشاء نسخة عالمية
+whale_monitor_global = ReliableWhaleMonitor()
+
+class DataManager:
+    def __init__(self, contracts_db):
+        self.contracts_db = contracts_db or {}
+        self.exchange = ccxt.kucoin()
+        self.exchange.rateLimit = 1000
+        self._http_client = None
+        self.fetch_stats = {'successful_fetches': 0, 'failed_fetches': 0, 'rate_limit_hits': 0}
+        
+        # ✅ نظامي مراقبة الحيتان
+        self.general_whale_monitor = ReliableWhaleMonitor(contracts_db)
+        self.specific_whale_monitor = SpecificWhaleMonitor(contracts_db, self.general_whale_monitor)
+    
+    async def initialize(self):
+        print("✅ DataManager initialized - DUAL WHALE MONITORING SYSTEM WITH RPC SUPPORT")
+    
+    async def close(self):
+        """إغلاق جميع العملاء بشكل آمن"""
+        if self._http_client:
+            await self._http_client.aclose()
+            self._http_client = None
+        await self.general_whale_monitor.close()
+        if hasattr(self.exchange, 'close'):
+            await self.exchange.close()
+
+    async def get_whale_data_safe_async(self, symbol):
+        """دالة آمنة لجلب بيانات الحيتان - الإصلاح"""
+        try:
+            # استخدام البيانات العامة للحيتان كبديل
+            general_analysis = await self.general_whale_monitor.get_comprehensive_whale_analysis()
+            
+            return {
+                'data_available': general_analysis.get('data_available', False),
+                'transfer_count': general_analysis.get('total_transactions', 0),
+                'total_volume': general_analysis.get('total_volume_usd', 0),
+                'source': 'general_whale_monitor',
+                'symbol': symbol
+            }
+        except Exception as e:
+            print(f"⚠️ فشل جلب بيانات الحيتان لـ {symbol}: {e}")
+            return {
+                'data_available': False,
+                'transfer_count': 0,
+                'total_volume': 0,
+                'source': 'fallback',
+                'symbol': symbol
+            }
+
+    async def get_enhanced_market_context(self):
+        """جلب سياق السوق مع بيانات الحيتان العامة والخاصة"""
+        try:
+            print("📊 جلب سياق السوق المحسن...")
+            
+            # ✅ جلب البيانات الأساسية
+            sentiment_task = self.get_sentiment_safe_async()
+            price_task = self._get_prices_safe_async()
+            general_whale_task = self.general_whale_monitor.get_comprehensive_whale_analysis()
+
+            results = await asyncio.gather(
+                sentiment_task, price_task, general_whale_task, 
+                return_exceptions=True
+            )
+            
+            sentiment_data = results[0] if not isinstance(results[0], Exception) else None
+            price_data = results[1] if not isinstance(results[1], Exception) else {}
+            general_whale_impact = results[2] if not isinstance(results[2], Exception) else None
+
+            bitcoin_price = price_data.get('bitcoin')
+            ethereum_price = price_data.get('ethereum')
+
+            # ✅ استخدام بيانات KuCoin كبديل إذا فشل CoinGecko
+            if not bitcoin_price or not ethereum_price:
+                print("🔄 استخدام بيانات KuCoin كبديل للأسعار...")
+                try:
+                    btc_ticker = await self.exchange.fetch_ticker('BTC/USDT')
+                    eth_ticker = await self.exchange.fetch_ticker('ETH/USDT')
+                    bitcoin_price = btc_ticker.get('last')
+                    ethereum_price = eth_ticker.get('last')
+                    print(f"✅ أسعار KuCoin البديلة: BTC=${bitcoin_price}, ETH=${ethereum_price}")
+                except Exception as e:
+                    print(f"❌ فشل جلب الأسعار البديلة: {e}")
+
+            if not bitcoin_price or not ethereum_price:
+                print("❌ لا توجد بيانات أسعار حقيقية")
+                return None
+
+            # ✅ تحليل اتجاه السوق
+            market_trend = self._determine_market_trend(bitcoin_price, sentiment_data, general_whale_impact)
+            
+            # ✅ استخدام البيانات الاحتياطية إذا لزم الأمر
+            if not general_whale_impact:
+                print("⚠️ استخدام بيانات حيتان احتياطية")
+                general_whale_impact = self.general_whale_monitor._get_fallback_analysis()
+
+            market_context = {
+                'timestamp': datetime.now().isoformat(),
+                'bitcoin_price_usd': bitcoin_price,
+                'ethereum_price_usd': ethereum_price,
+                'fear_and_greed_index': sentiment_data.get('feargreed_value') if sentiment_data else None,
+                'sentiment_class': sentiment_data.get('feargreed_class') if sentiment_data else None,
+                'general_whale_activity': await self._get_legacy_whale_data(general_whale_impact),
+                'whale_impact_analysis': general_whale_impact,
+                'market_trend': market_trend,
+                'btc_sentiment': 'BULLISH' if bitcoin_price and bitcoin_price > 60000 else 'BEARISH' if bitcoin_price and bitcoin_price < 55000 else 'NEUTRAL',
+                'data_sources': {
+                    'prices': bool(bitcoin_price),
+                    'sentiment': bool(sentiment_data and sentiment_data.get('feargreed_value')),
+                    'general_whale_data': general_whale_impact.get('data_available', False)
+                },
+                'data_quality': 'HIGH' if bitcoin_price and sentiment_data and general_whale_impact else 'LOW'
+            }
+            
+            print(f"📊 سياق السوق المحسن: BTC=${bitcoin_price:,.0f}, F&G={market_context['fear_and_greed_index']}")
+            
+            return market_context
+            
+        except Exception as e:
+            print(f"❌ فشل جلب سياق السوق المحسن: {e}")
+            return None
+
+    async def get_candidate_specific_whale_analysis(self, candidates):
+        """جلب تحليل الحيتان الخاص للمرشحين"""
+        if not candidates:
+            return {}
+            
+        symbols = [candidate.get('symbol') for candidate in candidates if candidate.get('symbol')]
+        return await self.specific_whale_monitor.get_specific_whale_activity(symbols)
+
+    async def get_sentiment_safe_async(self):
+        """جلب بيانات المشاعر الحقيقية فقط"""
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                print(f"🎭 جلب بيانات المشاعر الحقيقية - المحاولة {attempt + 1}/{max_retries}...")
+                
+                async with httpx.AsyncClient(timeout=15.0) as client:
+                    response = await client.get("https://api.alternative.me/fng/")
+                    response.raise_for_status()
+                    data = response.json()
+                    
+                    if 'data' not in data or not data['data']:
+                        raise ValueError("بيانات المشاعر غير متوفرة في الاستجابة")
+                    
+                    latest_data = data['data'][0]
+                    print(f"✅ تم جلب بيانات المشاعر الحقيقية: {latest_data['value']} ({latest_data['value_classification']})")
+                    
+                    return {
+                        "feargreed_value": int(latest_data['value']), 
+                        "feargreed_class": latest_data['value_classification'],
+                        "source": "alternative.me",
+                        "timestamp": datetime.now().isoformat()
+                    }
+                    
+            except Exception as e:
+                print(f"⚠️ فشل محاولة {attempt + 1}/{max_retries} لجلب بيانات المشاعر: {e}")
+                if attempt < max_retries - 1:
+                    await asyncio.sleep(2)
+        
+        print("🚨 فشل جميع محاولات جلب بيانات المشاعر الحقيقية")
+        return None
+
+    async def get_market_context_async(self):
+        """جلب سياق السوق مع البيانات الحقيقية فقط"""
+        return await self.get_enhanced_market_context()
+
+    async def _get_prices_safe_async(self):
+        """جلب الأسعار الحقيقية فقط"""
+        try:
+            async with httpx.AsyncClient(timeout=15.0) as client:
+                response = await client.get('https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,ethereum&vs_currencies=usd')
+                if response.status_code == 200:
+                    data = response.json()
+                    bitcoin_price = data.get('bitcoin', {}).get('usd')
+                    ethereum_price = data.get('ethereum', {}).get('usd')
+                    
+                    if bitcoin_price and ethereum_price:
+                        return {
+                            'bitcoin': bitcoin_price,
+                            'ethereum': ethereum_price
+                        }
+                elif response.status_code == 429:
+                    print("⚠️ CoinGecko rate limit reached, using exchange prices")
+        except Exception as e:
+            print(f"⚠️ فشل جلب الأسعار الحقيقية: {e}")
+        
+        return {}
+
+    async def _get_legacy_whale_data(self, whale_impact):
+        """تحويل بيانات التأثير إلى تنسيق legacy"""
+        if not whale_impact:
+            return {
+                'data_available': False,
+                'description': 'No real data available',
+                'critical_alert': False,
+                'sentiment': 'NEUTRAL',
+                'total_volume_usd': 0,
+                'transaction_count': 0
+            }
+        
+        sentiment_map = {
+            'BULLISH': 'BULLISH',
+            'SLIGHTLY_BULLISH': 'BULLISH',
+            'NEUTRAL': 'NEUTRAL',
+            'SLIGHTLY_BEARISH': 'BEARISH',
+            'BEARISH': 'BEARISH'
+        }
+        
+        sentiment = sentiment_map.get(
+            whale_impact.get('trading_intents', {}).get('market_sentiment', 'NEUTRAL'),
+            'NEUTRAL'
+        )
+        
+        critical_alert = whale_impact['overall_impact'] == 'HIGH'
+        
+        return {
+            'data_available': whale_impact['data_available'],
+            'description': whale_impact['description'],
+            'critical_alert': critical_alert,
+            'sentiment': sentiment,
+            'total_volume_usd': whale_impact['total_volume_usd'],
+            'transaction_count': whale_impact['total_transactions']
+        }
+
+    def _determine_market_trend(self, bitcoin_price, sentiment_data, whale_impact):
+        """تحديد اتجاه السوق بناءً على البيانات الحقيقية"""
+        try:
+            if not bitcoin_price:
+                return "unknown"
+            
+            score = 0
+            
+            # تحليل سعر البيتكوين الحقيقي
+            if bitcoin_price > 60000: 
+                score += 1
+            elif bitcoin_price < 55000: 
+                score -= 1
+            
+            # تحليل مؤشر الخوف والجشع الحقيقي
+            if sentiment_data:
+                fear_greed = sentiment_data.get('feargreed_value')
+                if fear_greed and fear_greed > 60: 
+                    score += 1
+                elif fear_greed and fear_greed < 40: 
+                    score -= 1
+            
+            # تحليل تأثير الحيتان الحقيقي
+            if whale_impact:
+                if whale_impact.get('overall_impact') == 'HIGH':
+                    score -= 1
+                elif whale_impact.get('overall_impact') == 'MEDIUM':
+                    score += 0
+                
+                # ✅ تحليل نوايا الحيتان
+                trading_intents = whale_impact.get('trading_intents', {})
+                market_sentiment = trading_intents.get('market_sentiment', 'NEUTRAL')
+                
+                if market_sentiment in ['BULLISH', 'SLIGHTLY_BULLISH']:
+                    score += 1
+                elif market_sentiment in ['BEARISH', 'SLIGHTLY_BEARISH']:
+                    score -= 1
+
+            if score >= 2: 
+                return "bull_market"
+            elif score <= -2: 
+                return "bear_market"
+            elif -1 <= score <= 1: 
+                return "sideways_market"
+            else:
+                return "volatile_market"
+                
+        except Exception as e:
+            print(f"⚠️ خطأ في تحديد اتجاه السوق: {e}")
+            return "unknown"
+
+    # ✅ باقي دوال DataManager الأساسية
+    @staticmethod
+    def adaptive_backoff(func):
+        @backoff.on_exception(backoff.expo, (RateLimitExceeded, DDoSProtection, NetworkError, httpx.TimeoutException), max_tries=3, max_time=20)
+        @wraps(func)
+        async def wrapper(*args, **kwargs): 
+            return await func(*args, **kwargs)
+        return wrapper
+
+    @adaptive_backoff
+    async def fetch_ohlcv_with_retry(self, symbol: str, timeframe: str, limit: int = 100):
+        """جلب بيانات OHLCV الحقيقية مع إعادة المحاولة"""
+        try:
+            candles = await self.exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)
+            self.fetch_stats['successful_fetches'] += 1
+            return candles
+        except RateLimitExceeded:
+            self.fetch_stats['rate_limit_hits'] += 1
+            print(f"⚠️ Rate limit hit for {symbol} on {timeframe}")
+            raise
+        except Exception as e:
+            self.fetch_stats['failed_fetches'] += 1
+            print(f"❌ Failed to fetch {symbol} {timeframe}: {e}")
+            raise
+
+    async def find_high_potential_candidates(self, n=100):
+        """إيجاد مرشحين عاليي الإمكانية مع بيانات الحيتان الخاصة"""
+        print("🚀 Starting High Potential Candidate Scan with Specific Whale Data...")
+        
+        try:
+            all_tickers = list((await self.exchange.fetch_tickers()).values())
+            if not all_tickers:
+                print("❌ Failed to fetch real tickers data")
+                return []
+
+            usdt_tickers = [
+                t for t in all_tickers 
+                if '/USDT' in t.get('symbol', '') 
+                and t.get('quoteVolume', 0) > 100000
+            ]
+            
+            if not usdt_tickers:
+                print("❌ No USDT pairs with sufficient real volume")
+                return []
+
+            top_volume_symbols = [
+                t['symbol'] for t in sorted(usdt_tickers, key=lambda x: x.get('quoteVolume', 0), reverse=True)[:200]
+            ]
+            
+            print(f"📊 Analyzing {len(top_volume_symbols)} symbols with highest real volume")
+            
+            # المسوحات الأساسية ببيانات حقيقية
+            momentum_candidates = await self._scan_for_momentum(usdt_tickers, top_n=30)
+            breakout_candidates = await self._scan_for_breakouts(top_volume_symbols, top_n=30)
+            volume_spike_candidates = await self._scan_for_volume_spike(top_volume_symbols, top_n=30)
+            
+            combined_candidates = {}
+            for candidates_dict in [momentum_candidates, breakout_candidates, volume_spike_candidates]:
+                for symbol, reasons in candidates_dict.items():
+                    combined_candidates.setdefault(symbol, set()).update(reasons)
+            
+            if not MARKET_STATE_OK:
+                print("🚨 Risk filter: Market state is NOT OK. Halting search.")
+                return []
+                
+            final_list = []
+            tickers_map = {t['symbol']: t for t in usdt_tickers}
+            
+            for symbol, reasons in combined_candidates.items():
+                ticker_info = tickers_map.get(symbol)
+                if not ticker_info: 
+                    continue
+                
+                change_percent = ticker_info.get('change', 0) or 0
+                if change_percent > 500:
+                    continue
+                
+                quote_volume = ticker_info.get('quoteVolume', 0)
+                if quote_volume < 50000:
+                    continue
+                    
+                final_list.append({
+                    'symbol': symbol, 
+                    'reasons': list(reasons), 
+                    'score': len(reasons),
+                    'change_percent': change_percent,
+                    'volume': quote_volume
+                })
+            
+            sorted_final_list = sorted(final_list, key=lambda x: x['score'], reverse=True)
+            
+            # ✅ إضافة بيانات الحيتان الخاصة للمرشحين
+            if sorted_final_list:
+                specific_whale_data = await self.get_candidate_specific_whale_analysis(sorted_final_list)
+                
+                for candidate in sorted_final_list:
+                    symbol = candidate.get('symbol')
+                    if symbol in specific_whale_data:
+                        candidate['specific_whale_activity'] = specific_whale_data[symbol]
+                        # تحسين النقاط بناءً على نشاط الحيتان الخاص
+                        whale_score = self._calculate_whale_score(specific_whale_data[symbol])
+                        candidate['whale_score'] = whale_score
+                        candidate['final_score'] = candidate.get('final_score', 0.5) + (whale_score * 0.2)
+                        print(f"🐋 Added specific whale data for {symbol} - Score: {whale_score:.2f}")
+            
+            print(f"✅ Real data scan complete. Found {len(sorted_final_list)} potential candidates with whale data.")
+            
+            return sorted_final_list[:n]
+            
+        except Exception as e:
+            print(f"❌ Failed to find high potential candidates with real data: {e}")
+            traceback.print_exc()
+            return []
+
+    def _calculate_whale_score(self, whale_data):
+        """حساب نقاط الحيتان بناءً على النشاط"""
+        if not whale_data:
+            return 0.0
+            
+        score = 0.0
+        
+        # نقاط بناءً على حجم التداول
+        total_volume = whale_data.get('total_volume_24h', 0)
+        if total_volume > 1000000:  # 1M+
+            score += 3.0
+        elif total_volume > 500000:  # 500K+
+            score += 2.0
+        elif total_volume > 100000:  # 100K+
+            score += 1.0
+            
+        # نقاط بناءً على عدد المعاملات
+        transaction_count = whale_data.get('whale_transaction_count', 0)
+        if transaction_count > 10:
+            score += 2.0
+        elif transaction_count > 5:
+            score += 1.0
+            
+        # نقاط بناءً على التحركات الكبيرة على الشبكة
+        large_tx_count = len(whale_data.get('large_transactions', []))
+        if large_tx_count > 5:
+            score += 2.0
+        elif large_tx_count > 2:
+            score += 1.0
+            
+        return min(score / 7.0, 1.0)  # تطبيع إلى 0-1
+
+    async def _scan_for_momentum(self, tickers, top_n=30):
+        """مسح الزخم ببيانات حقيقية"""
+        print("🔍 Running Real Momentum Scanner...")
+        valid_tickers = [t for t in tickers if t.get('change') is not None]
+        if not valid_tickers:
+            print("⚠️ No valid tickers for real momentum analysis")
+            return {}
+            
+        sorted_by_change = sorted(valid_tickers, key=lambda x: x.get('change', 0), reverse=True)
+        return {ticker['symbol']: {'momentum'} for ticker in sorted_by_change[:top_n]}
+
+    async def _scan_for_breakouts(self, symbols, top_n=30):
+        """مسح الانكسارات ببيانات حقيقية"""
+        print("🧱 Running Real Breakout Scanner...")
+        candidates = {}
+        tasks = [self.exchange.fetch_ohlcv(symbol, '1h', limit=24) for symbol in symbols]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        for i, result in enumerate(results):
+            if isinstance(result, Exception) or not result: 
+                continue
+                
+            df = pd.DataFrame(result, columns=['time', 'open', 'high', 'low', 'close', 'volume'])
+            if len(df) < 2: 
+                continue
+                
+            recent_high = df['high'].iloc[:-1].max()
+            current_price = df['close'].iloc[-1]
+            
+            if current_price > recent_high * 1.02:
+                candidates[symbols[i]] = {'breakout'}
+                if len(candidates) >= top_n: 
+                    break
+                    
+        print(f"✅ Found {len(candidates)} real breakout candidates")
+        return candidates
+        
+    async def _scan_for_volume_spike(self, symbols, top_n=30):
+        """مسح ارتفاع الحجم ببيانات حقيقية"""
+        print("💧 Running Real Volume Spike Scanner...")
+        candidates = {}
+        tasks = [self.exchange.fetch_ohlcv(symbol, '1h', limit=24) for symbol in symbols]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        for i, result in enumerate(results):
+            if isinstance(result, Exception) or not result: 
+                continue
+                
+            df = pd.DataFrame(result, columns=['time', 'open', 'high', 'low', 'close', 'volume'])
+            df['volume'] = pd.to_numeric(df['volume'])
+            if len(df) < 2: 
+                continue
+                
+            average_volume = df['volume'].iloc[:-1].mean()
+            current_volume = df['volume'].iloc[-1]
+            
+            if current_volume > average_volume * 3 and current_volume > 10000:
+                candidates[symbols[i]] = {'volume_spike'}
+                if len(candidates) >= top_n: 
+                    break
+                    
+        print(f"✅ Found {len(candidates)} real volume spike candidates")
+        return candidates
+
+    async def get_fast_pass_data_async(self, symbols_with_reasons):
+        """جلب بيانات سريعة حقيقية للمرشحين"""
+        timeframes = ['5m', '15m', '1h', '4h', '1d', '1w']
+        data = []
+        total = len(symbols_with_reasons)
+        completed = 0
+        success = 0
+        failed = 0
+        semaphore = asyncio.Semaphore(5)
+        
+        async def fetch_symbol_data(symbol_data, index):
+            nonlocal completed, success, failed
+            symbol = symbol_data['symbol']
+            reasons = symbol_data['reasons']
+            
+            async with semaphore:
+                try:
+                    print(f"⏳ [{index+1}/{total}] Fetching real data for {symbol}...")
+                    ohlcv_data = {}
+                    timeframes_fetched = 0
+                    
+                    for timeframe in timeframes:
+                        try:
+                            candles = await self.fetch_ohlcv_with_retry(symbol, timeframe, limit=100)
+                            
+                            if candles and len(candles) >= 20:
+                                cleaned_candles = []
+                                for candle in candles:
+                                    if len(candle) >= 6:
+                                        cleaned_candles.append([
+                                            candle[0],
+                                            float(candle[1]),
+                                            float(candle[2]),
+                                            float(candle[3]),
+                                            float(candle[4]),
+                                            float(candle[5])
+                                        ])
+                                
+                                if len(cleaned_candles) >= 20:
+                                    ohlcv_data[timeframe] = cleaned_candles
+                                    timeframes_fetched += 1
+                                else:
+                                    ohlcv_data[timeframe] = []
+                            else:
+                                ohlcv_data[timeframe] = []
+                                
+                        except Exception as e: 
+                            ohlcv_data[timeframe] = []
+                        
+                        await asyncio.sleep(0.2)
+                    
+                    completed += 1
+                    
+                    if timeframes_fetched >= 2:
+                        success += 1
+                        print(f"✅ [{index+1}/{total}] {symbol} - {timeframes_fetched}/{len(timeframes)} real timeframes")
+                        return {
+                            'symbol': symbol, 
+                            'ohlcv': ohlcv_data, 
+                            'reasons': reasons,
+                            'successful_timeframes': timeframes_fetched
+                        }
+                    else:
+                        failed += 1
+                        print(f"⚠️ [{index+1}/{total}] {symbol} - Insufficient real data")
+                        return None
+                        
+                except Exception as e: 
+                    completed += 1
+                    failed += 1
+                    print(f"❌ [{index+1}/{total}] {symbol} - Real data error")
+                    return None
+
+        print(f"📊 Starting real data fetch for {total} symbols")
+        
+        tasks = [fetch_symbol_data(symbol_data, i) for i, symbol_data in enumerate(symbols_with_reasons)]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        for result in results:
+            if isinstance(result, Exception): 
+                continue
+            elif result is not None: 
+                data.append(result)
+        
+        success_rate = (success/total*100) if total > 0 else 0
+        print(f"✅ Real data fetching complete! Success: {success}/{total} ({success_rate:.1f}%)")
+        
+        return data
+
+    async def get_latest_price_async(self, symbol):
+        """جلب آخر سعر حقيقي لرمز"""
+        max_retries = 2
+        for attempt in range(max_retries):
+            try:
+                ticker = await self.exchange.fetch_ticker(symbol)
+                price = ticker.get('last')
+                if price and price > 0:
+                    return price
+            except Exception as e:
+                print(f"⚠️ فشل محاولة {attempt + 1}/{max_retries} لجلب سعر حقيقي لـ {symbol}: {e}")
+                if attempt < max_retries - 1:
+                    await asyncio.sleep(1)
+        
+        print(f"❌ فشل جميع محاولات جلب سعر حقيقي لـ {symbol}")
+        return None
+
+    def get_performance_stats(self):
+        """الحصول على إحصائيات الأداء الحقيقية"""
+        total_attempts = self.fetch_stats['successful_fetches'] + self.fetch_stats['failed_fetches']
+        success_rate = (self.fetch_stats['successful_fetches'] / total_attempts * 100) if total_attempts > 0 else 0
+        
+        return {
+            'total_attempts': total_attempts,
+            'successful_fetches': self.fetch_stats['successful_fetches'],
+            'failed_fetches': self.fetch_stats['failed_fetches'],
+            'rate_limit_hits': self.fetch_stats['rate_limit_hits'],
+            'success_rate': f"{success_rate:.1f}%",
+            'timestamp': datetime.now().isoformat()
+        }
+
+print("✅ ENHANCED Data Manager Loaded - DUAL WHALE MONITORING SYSTEM - GENERAL & SPECIFIC ANALYSIS - MULTI-NETWORK RPC SUPPORT")

learning_engine (19).py

@@ -0,0 +1,644 @@
+import os
+import json
+import asyncio
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+from typing import Dict, List, Any
+import hashlib
+
+class LearningEngine:
+    def __init__(self, r2_service, data_manager):
+        self.r2_service = r2_service
+        self.data_manager = data_manager
+        self.weights = {}
+        self.performance_history = []
+        self.strategy_effectiveness = {}
+        self.market_patterns = {}
+        self.risk_profiles = {}
+        self.initialized = False
+        self.initialization_lock = asyncio.Lock()
+        
+    async def initialize(self):
+        """تهيئة نظام التعلم من R2"""
+        async with self.initialization_lock:
+            if self.initialized:
+                return
+                
+            print("🧠 تهيئة نظام التعلم الذاتي...")
+            try:
+                await self.load_weights_from_r2()
+                await self.load_performance_history()
+                self.initialized = True
+                print("✅ نظام التعلم جاهز - الأوزان محملة بنجاح")
+            except Exception as e:
+                print(f"⚠️ لم يتم تحميل الأوزان السابقة: {e} - سيتم البدء بأوزان افتراضية")
+                await self.initialize_default_weights()
+                self.initialized = True
+
+    async def initialize_enhanced(self):
+        """تهيئة محسنة لنظام التعلم"""
+        async with self.initialization_lock:
+            if self.initialized:
+                return
+                
+            print("🧠 تهيئة نظام التعلم الذاتي المحسّن...")
+            try:
+                await self.load_weights_from_r2()
+                await self.load_performance_history()
+                
+                # إصلاح هيكل الأوزان إذا لزم الأمر
+                await self.fix_weights_structure()
+                
+                # إذا لم تكن هناك بيانات كافية، بدء التعلم من الصفر
+                if not self.performance_history:
+                    print("🔰 بدء التعلم من الصفر - لا توجد بيانات تاريخية")
+                    await self.initialize_default_weights()
+                
+                self.initialized = True
+                print("✅ نظام التعلم المحسّن جاهز")
+                
+            except Exception as e:
+                print(f"⚠️ فشل التهيئة المحسنة: {e}")
+                await self.initialize_default_weights()
+                self.initialized = True
+    
+    async def fix_weights_structure(self):
+        """إصلاح هيكل الأوزان ليتوافق مع الكود"""
+        try:
+            # تحميل البيانات الحالية
+            key = "learning_engine_weights.json"
+            response = self.r2_service.s3_client.get_object(Bucket="trading", Key=key)
+            current_data = json.loads(response['Body'].read())
+            
+            # إذا كان الهيكل قديماً، قم بتحديثه
+            if 'strategy_weights' in current_data and 'last_updated' not in current_data:
+                fixed_data = {
+                    "weights": current_data,
+                    "last_updated": datetime.now().isoformat(),
+                    "version": "2.0",
+                    "performance_metrics": await self.calculate_performance_metrics()
+                }
+                
+                data_json = json.dumps(fixed_data, indent=2, ensure_ascii=False).encode('utf-8')
+                self.r2_service.s3_client.put_object(
+                    Bucket="trading", Key=key, Body=data_json, ContentType="application/json"
+                )
+                print("✅ تم إصلاح هيكل الأوزان بنجاح")
+                
+        except Exception as e:
+            print(f"⚠️ لم يتم إصلاح هيكل الأوزان: {e}")
+    
+    async def initialize_default_weights(self):
+        """تهيئة الأوزان الافتراضية - موزعة بشكل أفضل"""
+        self.weights = {
+            "strategy_weights": {
+                "trend_following": 0.18,
+                "mean_reversion": 0.15,  
+                "breakout_momentum": 0.22,
+                "volume_spike": 0.12,
+                "whale_tracking": 0.15,
+                "pattern_recognition": 0.10,
+                "hybrid_ai": 0.08
+            },
+            "technical_weights": {
+                "rsi": 0.15,
+                "macd": 0.18,
+                "ema_cross": 0.12,
+                "bollinger_bands": 0.10,
+                "volume_analysis": 0.15,
+                "support_resistance": 0.12,
+                "market_sentiment": 0.18
+            },
+            "risk_parameters": {
+                "max_position_size": 0.1,
+                "max_daily_loss": 0.02,
+                "stop_loss_base": 0.02,
+                "risk_reward_ratio": 2.0,
+                "volatility_adjustment": 1.0
+            },
+            "market_condition_weights": {
+                "bull_market": {
+                    "trend_following": 0.25,
+                    "breakout_momentum": 0.20,
+                    "whale_tracking": 0.15
+                },
+                "bear_market": {
+                    "mean_reversion": 0.25,
+                    "pattern_recognition": 0.20,
+                    "hybrid_ai": 0.15
+                },
+                "sideways_market": {
+                    "mean_reversion": 0.30,
+                    "volume_spike": 0.20,
+                    "pattern_recognition": 0.15
+                }
+            }
+        }
+    
+    async def load_weights_from_r2(self):
+        """تحميل الأوزان من R2"""
+        try:
+            key = "learning_engine_weights.json"
+            response = self.r2_service.s3_client.get_object(
+                Bucket="trading", Key=key
+            )
+            weights_data = json.loads(response['Body'].read())
+            
+            # التعامل مع الهيكل الجديد والقديم
+            if isinstance(weights_data, dict):
+                if 'weights' in weights_data:
+                    self.weights = weights_data['weights']
+                else:
+                    self.weights = weights_data
+                print(f"✅ تم تحميل الأوزان من R2 بنجاح. إصدار الهيكل: {'جديد' if 'weights' in weights_data else 'قديم'}")
+            else:
+                raise ValueError("هيكل الأوزان غير صحيح")
+                
+        except Exception as e:
+            print(f"❌ فشل تحميل الأوزان: {e}")
+            await self.initialize_default_weights()
+            await self.save_weights_to_r2()
+    
+    async def save_weights_to_r2(self):
+        """حفظ الأوزان إلى R2"""
+        try:
+            key = "learning_engine_weights.json"
+            weights_data = {
+                "weights": self.weights,
+                "last_updated": datetime.now().isoformat(),
+                "version": "2.0",
+                "performance_metrics": await self.calculate_performance_metrics()
+            }
+            
+            data_json = json.dumps(weights_data, indent=2, ensure_ascii=False).encode('utf-8')
+            self.r2_service.s3_client.put_object(
+                Bucket="trading",
+                Key=key, 
+                Body=data_json, 
+                ContentType="application/json"
+            )
+            print("✅ تم حفظ الأوزان إلى R2 بنجاح")
+        except Exception as e:
+            print(f"❌ فشل حفظ الأوزان: {e}")
+    
+    async def load_performance_history(self):
+        """تحميل سجل الأداء"""
+        try:
+            key = "learning_performance_history.json"
+            response = self.r2_service.s3_client.get_object(
+                Bucket="trading", Key=key
+            )
+            history_data = json.loads(response['Body'].read())
+            self.performance_history = history_data.get("history", [])
+            print(f"✅ تم تحميل سجل الأداء - {len(self.performance_history)} تسجيل")
+        except Exception as e:
+            print(f"⚠️ لم يتم تحميل سجل الأداء: {e}")
+            self.performance_history = []
+    
+    async def save_performance_history(self):
+        """حفظ سجل الأداء"""
+        try:
+            key = "learning_performance_history.json"
+            history_data = {
+                "history": self.performance_history[-1000:],
+                "last_updated": datetime.now().isoformat()
+            }
+            
+            data_json = json.dumps(history_data, indent=2, ensure_ascii=False).encode('utf-8')
+            self.r2_service.s3_client.put_object(
+                Bucket="trading",
+                Key=key, 
+                Body=data_json, 
+                ContentType="application/json"
+            )
+        except Exception as e:
+            print(f"❌ فشل حفظ سجل الأداء: {e}")
+    
+    async def analyze_trade_outcome(self, trade_data, outcome):
+        """تحليل نتيجة الصفقة وتحديث الأوزان - الإصدار المحسّن"""
+        if not self.initialized:
+            await self.initialize()
+            
+        try:
+            # استخراج الاستراتيجية من بيانات الصفقة
+            strategy = trade_data.get('strategy', 'unknown')
+            if strategy == 'unknown':
+                decision_data = trade_data.get('decision_data', {})
+                strategy = decision_data.get('strategy', 'unknown')
+            
+            # الحصول على سياق السوق الحقيقي
+            market_context = await self.get_current_market_conditions()
+            
+            analysis_entry = {
+                "timestamp": datetime.now().isoformat(),
+                "trade_data": trade_data,
+                "outcome": outcome,
+                "market_conditions": market_context,
+                "strategy_used": strategy,
+                "symbol": trade_data.get('symbol', 'unknown'),
+                "pnl_usd": trade_data.get('pnl_usd', 0),
+                "pnl_percent": trade_data.get('pnl_percent', 0)
+            }
+            
+            self.performance_history.append(analysis_entry)
+            
+            await self.update_strategy_effectiveness(analysis_entry)
+            await self.update_market_patterns(analysis_entry)
+            
+            # ✅ التحديث الهام: تحديث الأوزان بعد كل صفقة في البداية
+            if len(self.performance_history) <= 10:  # أول 10 صفقات
+                await self.adapt_weights_based_on_performance()
+                await self.save_weights_to_r2()
+                await self.save_performance_history()
+            else:
+                # بعد ذلك، تحديث كل 3 صفقات
+                if len(self.performance_history) % 3 == 0:
+                    await self.adapt_weights_based_on_performance()
+                    await self.save_weights_to_r2()
+                    await self.save_performance_history()
+            
+            print(f"📊 تم تحليل صفقة {trade_data.get('symbol')} - الاستراتيجية: {strategy} - النتيجة: {outcome} - PnL: {trade_data.get('pnl_percent', 0):.2f}%")
+            
+        except Exception as e:
+            print(f"❌ فشل تحليل نتيجة الصفقة: {e}")
+    
+    async def update_strategy_effectiveness(self, analysis_entry):
+        """تحديث فعالية الاستراتيجيات"""
+        strategy = analysis_entry['strategy_used']
+        outcome = analysis_entry['outcome']
+        market_condition = analysis_entry['market_conditions']['current_trend']
+        pnl_percent = analysis_entry.get('pnl_percent', 0)
+        
+        if strategy not in self.strategy_effectiveness:
+            self.strategy_effectiveness[strategy] = {
+                "total_trades": 0,
+                "successful_trades": 0,
+                "total_profit": 0,
+                "total_pnl_percent": 0,
+                "market_conditions": {}
+            }
+        
+        self.strategy_effectiveness[strategy]["total_trades"] += 1
+        self.strategy_effectiveness[strategy]["total_pnl_percent"] += pnl_percent
+        
+        # تحديد النجاح بناءً على النتيجة والأداء
+        is_success = outcome in ["SUCCESS", "CLOSED_BY_REANALYSIS", "CLOSED_BY_MONITOR"] and pnl_percent > 0
+        if is_success:
+            self.strategy_effectiveness[strategy]["successful_trades"] += 1
+        
+        if market_condition not in self.strategy_effectiveness[strategy]["market_conditions"]:
+            self.strategy_effectiveness[strategy]["market_conditions"][market_condition] = {
+                "trades": 0,
+                "successes": 0,
+                "total_pnl": 0
+            }
+        
+        self.strategy_effectiveness[strategy]["market_conditions"][market_condition]["trades"] += 1
+        self.strategy_effectiveness[strategy]["market_conditions"][market_condition]["total_pnl"] += pnl_percent
+        if is_success:
+            self.strategy_effectiveness[strategy]["market_conditions"][market_condition]["successes"] += 1
+    
+    async def update_market_patterns(self, analysis_entry):
+        """تحديث أنماط السوق"""
+        market_condition = analysis_entry['market_conditions']['current_trend']
+        symbol = analysis_entry['symbol']
+        outcome = analysis_entry['outcome']
+        pnl_percent = analysis_entry.get('pnl_percent', 0)
+        
+        if market_condition not in self.market_patterns:
+            self.market_patterns[market_condition] = {
+                "total_trades": 0,
+                "successful_trades": 0,
+                "total_pnl_percent": 0,
+                "best_performing_strategies": {},
+                "best_performing_symbols": {}
+            }
+        
+        self.market_patterns[market_condition]["total_trades"] += 1
+        self.market_patterns[market_condition]["total_pnl_percent"] += pnl_percent
+        
+        is_success = outcome in ["SUCCESS", "CLOSED_BY_REANALYSIS", "CLOSED_BY_MONITOR"] and pnl_percent > 0
+        if is_success:
+            self.market_patterns[market_condition]["successful_trades"] += 1
+        
+        strategy = analysis_entry['strategy_used']
+        if strategy not in self.market_patterns[market_condition]["best_performing_strategies"]:
+            self.market_patterns[market_condition]["best_performing_strategies"][strategy] = {
+                "count": 0,
+                "total_pnl": 0
+            }
+        
+        self.market_patterns[market_condition]["best_performing_strategies"][strategy]["count"] += 1
+        self.market_patterns[market_condition]["best_performing_strategies"][strategy]["total_pnl"] += pnl_percent
+        
+        if symbol not in self.market_patterns[market_condition]["best_performing_symbols"]:
+            self.market_patterns[market_condition]["best_performing_symbols"][symbol] = {
+                "count": 0,
+                "total_pnl": 0
+            }
+        
+        self.market_patterns[market_condition]["best_performing_symbols"][symbol]["count"] += 1
+        self.market_patterns[market_condition]["best_performing_symbols"][symbol]["total_pnl"] += pnl_percent
+    
+    async def adapt_weights_based_on_performance(self):
+        """تعديل الأوزان بناءً على الأداء - الإصدار المحسّن"""
+        print("🔄 تحديث الأوزان بناءً على الأداء...")
+        
+        try:
+            # إذا لم تكن هناك بيانات كافية، استخدم تحديثاً تدريجياً
+            if not self.strategy_effectiveness:
+                print("⚠️ لا توجد بيانات أداء كافية، استخدام تحديث تدريجي")
+                await self.gradual_weights_adjustment()
+                return
+
+            # تحديث أوزان الاستراتيجيات بناءً على الأداء الحقيقي
+            total_performance = 0
+            strategy_performance = {}
+            
+            for strategy, data in self.strategy_effectiveness.items():
+                if data["total_trades"] > 0:
+                    success_rate = data["successful_trades"] / data["total_trades"]
+                    avg_pnl = data["total_pnl_percent"] / data["total_trades"]
+                    
+                    # حساب الأداء المركب
+                    composite_performance = (success_rate * 0.7) + (min(avg_pnl, 10) / 10 * 0.3)
+                    strategy_performance[strategy] = composite_performance
+                    total_performance += composite_performance
+            
+            # إذا كان هناك أداء كافٍ، قم بالتحديث
+            if total_performance > 0 and strategy_performance:
+                for strategy, performance in strategy_performance.items():
+                    current_weight = self.weights["strategy_weights"].get(strategy, 0.1)
+                    # تحديث تدريجي لتجنب التغيرات المفاجئة
+                    new_weight = current_weight * 0.7 + (performance * 0.3)
+                    self.weights["strategy_weights"][strategy] = new_weight
+                
+                # تطبيع الأوزان
+                self.normalize_weights()
+                print("✅ تم تحديث الأوزان بناءً على الأداء الحقيقي")
+            else:
+                await self.gradual_weights_adjustment()
+                
+        except Exception as e:
+            print(f"❌ فشل تحديث الأوزان: {e}")
+            await self.gradual_weights_adjustment()
+
+    async def gradual_weights_adjustment(self):
+        """تعديل تدريجي للأوزان لتحسين الأداء"""
+        print("📈 إجراء تعديل تدريجي على الأوزان...")
+        
+        # زيادة وزن الاستراتيجيات التي تعتمد على البيانات المتاحة
+        if self.market_patterns:
+            for market_condition, data in self.market_patterns.items():
+                if data.get("total_trades", 0) > 0:
+                    best_strategy = max(data["best_performing_strategies"].items(), 
+                                      key=lambda x: x[1]["total_pnl"])[0] if data["best_performing_strategies"] else None
+                    if best_strategy:
+                        current_weight = self.weights["strategy_weights"].get(best_strategy, 0.1)
+                        self.weights["strategy_weights"][best_strategy] = min(current_weight * 1.1, 0.3)
+        
+        self.normalize_weights()
+        print("✅ تم التعديل التدريجي للأوزان")
+
+    def normalize_weights(self):
+        """تطبيع الأوزان للتأكد من أن مجموعها 1"""
+        total = sum(self.weights["strategy_weights"].values())
+        if total > 0:
+            for strategy in self.weights["strategy_weights"]:
+                self.weights["strategy_weights"][strategy] /= total
+
+    async def get_current_market_conditions(self):
+        """الحصول على ظروف السوق الحالية - بيانات حقيقية"""
+        try:
+            if not self.data_manager:
+                raise ValueError("DataManager غير متوفر")
+                
+            market_context = await self.data_manager.get_market_context_async()
+            if not market_context:
+                raise ValueError("فشل جلب سياق السوق")
+            
+            return {
+                "current_trend": market_context.get('market_trend', 'sideways_market'),
+                "volatility": self._calculate_market_volatility(market_context),
+                "market_sentiment": market_context.get('btc_sentiment', 'NEUTRAL'),
+                "whale_activity": market_context.get('general_whale_activity', {}).get('sentiment', 'NEUTRAL'),
+                "fear_greed_index": market_context.get('fear_and_greed_index', 50)
+            }
+        except Exception as e:
+            print(f"⚠️ فشل الحصول على ظروف السوق: {e}")
+            return {
+                "current_trend": "sideways_market",
+                "volatility": "medium",
+                "market_sentiment": "neutral",
+                "whale_activity": "low",
+                "fear_greed_index": 50
+            }
+    
+    def _calculate_market_volatility(self, market_context):
+        """حساب تقلبية السوق بناءً على البيانات الحقيقية"""
+        try:
+            btc_price = market_context.get('bitcoin_price_usd', 0)
+            fear_greed = market_context.get('fear_and_greed_index', 50)
+            whale_sentiment = market_context.get('general_whale_activity', {}).get('sentiment', 'NEUTRAL')
+            
+            volatility_score = 0
+            
+            # تحليل سعر البيتكوين (تغيرات كبيرة = تقلبية عالية)
+            if btc_price > 0:
+                # هذا مؤشر مبسط - في التطبيق الحقيقي نحتاج بيانات تاريخية
+                if abs(fear_greed - 50) > 20:
+                    volatility_score += 1
+            
+            # تحليل نشاط الحيتان
+            if whale_sentiment in ['BULLISH', 'BEARISH']:
+                volatility_score += 1
+            elif whale_sentiment == 'SLIGHTLY_BULLISH':
+                volatility_score += 0.5
+            
+            if volatility_score >= 1.5:
+                return "high"
+            elif volatility_score >= 0.5:
+                return "medium"
+            else:
+                return "low"
+                
+        except Exception as e:
+            print(f"⚠️ خطأ في حساب التقلبية: {e}")
+            return "medium"
+    
+    async def calculate_performance_metrics(self):
+        """حساب مقاييس الأداء"""
+        if not self.performance_history:
+            return {"status": "لا توجد بيانات أداء بعد"}
+        
+        recent_trades = self.performance_history[-50:]  # آخر 50 صفقة فقط
+        
+        total_trades = len(recent_trades)
+        successful_trades = sum(1 for trade in recent_trades 
+                              if trade['outcome'] in ["SUCCESS", "CLOSED_BY_REANALYSIS", "CLOSED_BY_MONITOR"] and trade.get('pnl_percent', 0) > 0)
+        success_rate = successful_trades / total_trades if total_trades > 0 else 0
+        
+        total_pnl = sum(trade.get('pnl_percent', 0) for trade in recent_trades)
+        avg_pnl = total_pnl / total_trades if total_trades > 0 else 0
+        
+        strategy_performance = {}
+        for strategy, data in self.strategy_effectiveness.items():
+            if data["total_trades"] > 0:
+                strategy_success_rate = data["successful_trades"] / data["total_trades"]
+                strategy_avg_pnl = data["total_pnl_percent"] / data["total_trades"]
+                strategy_performance[strategy] = {
+                    "success_rate": strategy_success_rate,
+                    "avg_pnl_percent": strategy_avg_pnl,
+                    "total_trades": data["total_trades"],
+                    "successful_trades": data["successful_trades"]
+                }
+        
+        market_performance = {}
+        for condition, data in self.market_patterns.items():
+            if data["total_trades"] > 0:
+                market_success_rate = data["successful_trades"] / data["total_trades"]
+                market_avg_pnl = data["total_pnl_percent"] / data["total_trades"]
+                market_performance[condition] = {
+                    "success_rate": market_success_rate,
+                    "avg_pnl_percent": market_avg_pnl,
+                    "total_trades": data["total_trades"]
+                }
+        
+        return {
+            "overall_success_rate": success_rate,
+            "overall_avg_pnl_percent": avg_pnl,
+            "total_analyzed_trades": len(self.performance_history),
+            "recent_trades_analyzed": total_trades,
+            "strategy_performance": strategy_performance,
+            "market_performance": market_performance,
+            "last_updated": datetime.now().isoformat()
+        }
+    
+    async def get_optimized_strategy_weights(self, market_condition):
+        """الحصول على أوزان استراتيجية محسنة - الإصدار المصحح"""
+        try:
+            if not self.initialized:
+                print("⚠️ نظام التعلم غير مهيء، استخدام الأوزان الافتراضية")
+                return await self.get_default_strategy_weights()
+            
+            # ✅ التحقق من وجود الأوزان وهيكلتها بشكل صحيح
+            if (not self.weights or 
+                "strategy_weights" not in self.weights or 
+                not self.weights["strategy_weights"]):
+                print("⚠️ الأوزان غير متوفرة أو فارغة، استخدام الأوزان الافتراضية")
+                return await self.get_default_strategy_weights()
+            
+            base_weights = self.weights["strategy_weights"].copy()
+            
+            # ✅ التحقق من أن الأوزان تحتوي على استراتيجيات فعلية
+            if not any(weight > 0 for weight in base_weights.values()):
+                print("⚠️ جميع الأوزان صفر، استخدام الأوزان الافتراضية")
+                return await self.get_default_strategy_weights()
+            
+            print(f"✅ استخدام الأوزان المتعلمة: {base_weights}")
+            return base_weights
+                
+        except Exception as e:
+            print(f"❌ فشل في حساب الأوزان المحسنة: {e}")
+            return await self.get_default_strategy_weights()
+    
+    async def get_default_strategy_weights(self):
+        """إرجاع الأوزان الافتراضية"""
+        return {
+            "trend_following": 0.18,
+            "mean_reversion": 0.15,  
+            "breakout_momentum": 0.22,
+            "volume_spike": 0.12,
+            "whale_tracking": 0.15,
+            "pattern_recognition": 0.10,
+            "hybrid_ai": 0.08
+        }
+    
+    async def get_risk_parameters(self, symbol_volatility):
+        """الحصول على معايير المخاطرة المحسنة"""
+        if not self.weights or "risk_parameters" not in self.weights:
+            await self.initialize_default_weights()
+        
+        risk_params = self.weights.get("risk_parameters", {}).copy()
+        
+        # تعديل معايير المخاطرة بناءً على تقلبية الرمز
+        if symbol_volatility == "HIGH":
+            risk_params["stop_loss_base"] *= 1.5
+            risk_params["max_position_size"] *= 0.7
+            risk_params["risk_reward_ratio"] = 1.5  # تخفيض نسبة المكافأة/المخاطرة للتقليل العالي
+        elif symbol_volatility == "LOW":
+            risk_params["stop_loss_base"] *= 0.7
+            risk_params["max_position_size"] *= 1.2
+            risk_params["risk_reward_ratio"] = 2.5  # زيادة النسبة للتقليل المنخفض
+        
+        return risk_params
+    
+    async def suggest_improvements(self):
+        """اقتراح تحسينات بناءً على تحليل الأداء"""
+        improvements = []
+        
+        if not self.performance_history:
+            improvements.append("📊 ابدأ بجمع بيانات الأداء من الصفقات الأولى")
+            return improvements
+        
+        # تحليل أداء الاستراتيجيات
+        for strategy, data in self.strategy_effectiveness.items():
+            if data["total_trades"] >= 3:
+                success_rate = data["successful_trades"] / data["total_trades"]
+                avg_pnl = data["total_pnl_percent"] / data["total_trades"]
+                
+                if success_rate < 0.3 and avg_pnl < 0:
+                    improvements.append(f"🚨 استراتيجية {strategy} ضعيفة الأداء ({success_rate:.1%} نجاح، {avg_pnl:+.1f}% متوسط) - يقترح تقليل استخدامها")
+                elif success_rate > 0.6 and avg_pnl > 2:
+                    improvements.append(f"✅ استراتيجية {strategy} ممتازة الأداء ({success_rate:.1%} نجاح، {avg_pnl:+.1f}% متوسط) - يقترح زيادة استخدامها")
+                elif success_rate > 0.7:
+                    improvements.append(f"🎯 استراتيجية {strategy} عالية النجاح ({success_rate:.1%}) - التركيز على جودة الصفقات")
+        
+        # تحليل أداء ظروف السوق
+        for market_condition, data in self.market_patterns.items():
+            if data["total_trades"] >= 5:
+                success_rate = data["successful_trades"] / data["total_trades"]
+                avg_pnl = data["total_pnl_percent"] / data["total_trades"]
+                
+                if success_rate < 0.4:
+                    improvements.append(f"⚠️ الأداء ضعيف في سوق {market_condition} ({success_rate:.1%} نجاح) - يحتاج مراجعة الاستراتيجيات")
+                
+                # العثور على أفضل استراتيجية لهذا السوق
+                best_strategy = None
+                best_performance = -100
+                for strategy, stats in data["best_performing_strategies"].items():
+                    if stats["count"] >= 2:
+                        strategy_avg_pnl = stats["total_pnl"] / stats["count"]
+                        if strategy_avg_pnl > best_performance:
+                            best_performance = strategy_avg_pnl
+                            best_strategy = strategy
+                
+                if best_strategy and best_performance > 1:
+                    improvements.append(f"📈 أفضل استراتيجية في {market_condition}: {best_strategy} ({best_performance:+.1f}% متوسط ربح)")
+        
+        if not improvements:
+            improvements.append("📊 لا توجد تحسينات مقترحة حالياً - استمر في جمع البيانات")
+        
+        return improvements
+
+    async def force_strategy_learning(self):
+        """إجبار النظام على التعلم من البيانات الحالية"""
+        print("🧠 إجبار تحديث الاستراتيجيات من البيانات الحالية...")
+        
+        if not self.performance_history:
+            print("⚠️ لا توجد بيانات أداء للتعلم منها")
+            return
+        
+        # تحديث فعالية الاستراتيجيات من البيانات التاريخية
+        for entry in self.performance_history:
+            await self.update_strategy_effectiveness(entry)
+            await self.update_market_patterns(entry)
+        
+        # تحديث الأوزان فوراً
+        await self.adapt_weights_based_on_performance()
+        await self.save_weights_to_r2()
+        
+        print("✅ تم إجبار تحديث الاستراتيجيات بنجاح")
+
+print("✅ نظام التعلم الذاتي المحسن محمل - جاهز للتعلم والتكيف المستمر")

r2 (29).py

@@ -0,0 +1,648 @@
+# r2 (23).py - الإصلاحات
+import os
+import traceback
+import json
+from datetime import datetime, timedelta
+import asyncio
+import time
+import boto3
+from botocore.exceptions import NoCredentialsError, ClientError
+
+# --- R2 Service Configuration ---
+R2_ACCOUNT_ID = os.getenv("R2_ACCOUNT_ID")
+R2_ACCESS_KEY_ID = os.getenv("R2_ACCESS_KEY_ID")
+R2_SECRET_ACCESS_KEY = os.getenv("R2_SECRET_ACCESS_KEY")
+BUCKET_NAME = "trading"
+INITIAL_CAPITAL = 10.0
+
+class R2Service:
+    def __init__(self):
+        try:
+            endpoint_url = f"https://{R2_ACCOUNT_ID}.r2.cloudflarestorage.com"
+            self.s3_client = boto3.client(
+                's3',
+                endpoint_url=endpoint_url,
+                aws_access_key_id=R2_ACCESS_KEY_ID,
+                aws_secret_access_key=R2_SECRET_ACCESS_KEY,
+            )
+            self.lock_acquired = False
+            self.BUCKET_NAME = BUCKET_NAME
+            
+            self._open_trades_warning_printed = False
+            self._portfolio_warning_printed = False
+            self._contracts_warning_printed = False
+            
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize S3 client: {e}")
+
+    def acquire_lock(self, max_retries=3):
+        """Acquires a lock file in R2 with retry logic."""
+        lock_path = "lock.txt"
+        
+        for attempt in range(max_retries):
+            try:
+                try:
+                    self.s3_client.head_object(Bucket=BUCKET_NAME, Key=lock_path)
+                    print(f"🔒 Lock file exists. Attempt {attempt + 1}/{max_retries}. Waiting...")
+                    time.sleep(1)
+                except ClientError as e:
+                    if e.response['Error']['Code'] == '404':
+                        self.s3_client.put_object(Bucket=BUCKET_NAME, Key=lock_path, Body=b'')
+                        self.lock_acquired = True
+                        print("✅ Lock acquired.")
+                        return True
+                    else:
+                        raise
+            except Exception as e:
+                print(f"❌ Failed to acquire lock: {e}")
+                time.sleep(1)
+        
+        print(f"❌ Failed to acquire lock after {max_retries} attempts.")
+        return False
+
+    def release_lock(self):
+        """Releases the lock file from R2."""
+        lock_path = "lock.txt"
+        if self.lock_acquired:
+            try:
+                self.s3_client.delete_object(Bucket=BUCKET_NAME, Key=lock_path)
+                print("✅ Lock released.")
+                self.lock_acquired = False
+            except Exception as e:
+                print(f"❌ Failed to release lock: {e}")
+
+    async def close_trade_async(self, trade_to_close, close_price):
+        """Closes a trade, archives it, updates summary, and updates portfolio capital."""
+        try:
+            trade_to_close['status'] = 'CLOSED'
+            trade_to_close['close_price'] = close_price
+            trade_to_close['close_timestamp'] = datetime.now().isoformat()
+            trade_to_close['is_monitored'] = False
+            
+            entry_price = trade_to_close['entry_price']
+            position_size = trade_to_close['position_size_usd']
+            trade_type = trade_to_close.get('trade_type', 'LONG')
+            strategy = trade_to_close.get('strategy', 'unknown')
+            
+            # ✅ الإصلاح: حساب PnL بشكل صحيح
+            pnl = 0.0
+            pnl_percent = 0.0
+            
+            if entry_price and entry_price > 0 and close_price and close_price > 0:
+                try:
+                    if trade_type == 'LONG':
+                        pnl_percent = ((close_price - entry_price) / entry_price) * 100
+                        pnl = position_size * (pnl_percent / 100)
+                    elif trade_type == 'SHORT':
+                        pnl_percent = ((entry_price - close_price) / entry_price) * 100
+                        pnl = position_size * (pnl_percent / 100)
+                    
+                    print(f"💰 PnL Calculation: Entry=${entry_price:.6f}, Close=${close_price:.6f}, "
+                          f"Position=${position_size:.2f}, Type={trade_type}, "
+                          f"PnL=${pnl:.4f} ({pnl_percent:+.4f}%)")
+                          
+                except (TypeError, ZeroDivisionError) as calc_error:
+                    print(f"⚠️ PnL calculation error: {calc_error}")
+                    pnl = 0.0
+                    pnl_percent = 0.0
+            else:
+                print(f"⚠️ Invalid prices for PnL calculation: Entry={entry_price}, Close={close_price}")
+                    
+            trade_to_close['pnl_usd'] = pnl
+            trade_to_close['pnl_percent'] = pnl_percent
+
+            await self._archive_closed_trade_async(trade_to_close)
+            await self._update_trade_summary_async(trade_to_close)
+
+            # ✅ الإصلاح: تحديث رأس المال بشكل صحيح
+            portfolio_state = await self.get_portfolio_state_async()
+            current_capital = portfolio_state.get("current_capital_usd", 0)
+            invested_capital = portfolio_state.get("invested_capital_usd", 0)
+            
+            # حساب رأس المال الجديد
+            new_capital = current_capital + position_size + pnl
+            
+            portfolio_state["current_capital_usd"] = new_capital
+            portfolio_state["invested_capital_usd"] = 0.0
+            
+            if pnl > 0:
+                portfolio_state["winning_trades"] = portfolio_state.get("winning_trades", 0) + 1
+                portfolio_state["total_profit_usd"] = portfolio_state.get("total_profit_usd", 0.0) + pnl
+            elif pnl < 0:
+                portfolio_state["total_loss_usd"] = portfolio_state.get("total_loss_usd", 0.0) + abs(pnl)
+            
+            await self.save_portfolio_state_async(portfolio_state)
+            
+            print(f"📈 Trade PnL: ${pnl:.4f} ({pnl_percent:+.4f}%). "
+                  f"New available capital: ${new_capital:.4f}. Strategy: {strategy}")
+
+            open_trades = await self.get_open_trades_async()
+            trades_to_keep = [t for t in open_trades if t.get('id') != trade_to_close.get('id')]
+            await self.save_open_trades_async(trades_to_keep)
+            
+            print(f"✅ Trade for {trade_to_close.get('symbol')} closed and archived successfully. Strategy: {strategy}")
+
+            await self.save_system_logs_async({
+                "trade_closed": True,
+                "symbol": trade_to_close.get('symbol'),
+                "entry_price": entry_price,
+                "close_price": close_price,
+                "pnl_usd": pnl,
+                "pnl_percent": pnl_percent,
+                "new_capital": new_capital,
+                "strategy": strategy,
+                "position_size": position_size,
+                "trade_type": trade_type
+            })
+
+        except Exception as e:
+            print(f"❌ Failed to close trade: {e}")
+            traceback.print_exc()
+            raise
+
+    # باقي الدوال تبقى كما هي بدون تغيير
+    async def save_candidates_data_async(self, candidates_data, reanalysis_data):
+        """حفظ بيانات المرشحين العشرة وبيانات إعادة التحليل"""
+        try:
+            key = "candidates_data.json"
+            data = {
+                "timestamp": datetime.now().isoformat(),
+                "top_candidates": candidates_data,
+                "reanalysis_data": reanalysis_data
+            }
+            
+            data_json = json.dumps(data, indent=2, ensure_ascii=False).encode('utf-8')
+            self.s3_client.put_object(
+                Bucket=BUCKET_NAME, Key=key, Body=data_json, ContentType="application/json"
+            )
+            print(f"✅ Candidates data saved to R2: {len(candidates_data) if candidates_data else 0} candidates")
+        except Exception as e:
+            print(f"❌ Failed to save candidates data: {e}")
+
+    async def save_llm_responses_async(self, symbol, prompt, full_response, parsed_decision):
+        """حفظ إجابات النموذج الكاملة"""
+        try:
+            key = "llm_responses.json"
+            try:
+                response = self.s3_client.get_object(Bucket=BUCKET_NAME, Key=key)
+                existing_data = json.loads(response['Body'].read())
+            except ClientError as e:
+                if e.response['Error']['Code'] == 'NoSuchKey':
+                    existing_data = {"responses": []}
+                else:
+                    raise
+            
+            new_response = {
+                "timestamp": datetime.now().isoformat(),
+                "symbol": symbol,
+                "prompt": prompt[:2000] + "..." if len(prompt) > 2000 else prompt,
+                "full_response": full_response,
+                "parsed_decision": parsed_decision
+            }
+            
+            existing_data["responses"].append(new_response)
+            
+            if len(existing_data["responses"]) > 1000:
+                existing_data["responses"] = existing_data["responses"][-1000:]
+            
+            data_json = json.dumps(existing_data, indent=2, ensure_ascii=False).encode('utf-8')
+            self.s3_client.put_object(
+                Bucket=BUCKET_NAME, Key=key, Body=data_json, ContentType="application/json"
+            )
+            print(f"✅ LLM response saved for {symbol}")
+        except Exception as e:
+            print(f"❌ Failed to save LLM response: {e}")
+
+    async def save_system_logs_async(self, log_data):
+        """حفظ سجلات النظام"""
+        try:
+            key = "system_logs.json"
+            try:
+                response = self.s3_client.get_object(Bucket=BUCKET_NAME, Key=key)
+                existing_logs = json.loads(response['Body'].read())
+            except ClientError as e:
+                if e.response['Error']['Code'] == 'NoSuchKey':
+                    existing_logs = {"logs": []}
+                else:
+                    raise
+            
+            log_entry = {
+                "timestamp": datetime.now().isoformat(),
+                **log_data
+            }
+            
+            existing_logs["logs"].append(log_entry)
+            
+            if len(existing_logs["logs"]) > 2000:
+                existing_logs["logs"] = existing_logs["logs"][-2000:]
+            
+            data_json = json.dumps(existing_logs, indent=2, ensure_ascii=False).encode('utf-8')
+            self.s3_client.put_object(
+                Bucket=BUCKET_NAME, Key=key, Body=data_json, ContentType="application/json"
+            )
+            print(f"✅ System log saved: {log_data.get('cycle_started', log_data.get('cycle_completed', 'event'))}")
+        except Exception as e:
+            print(f"❌ Failed to save system logs: {e}")
+
+    async def save_learning_data_async(self, learning_data):
+        """حفظ بيانات التعلم"""
+        try:
+            key = "learning_data.json"
+            data = {
+                "timestamp": datetime.now().isoformat(),
+                "learning_data": learning_data
+            }
+            
+            data_json = json.dumps(data, indent=2, ensure_ascii=False).encode('utf-8')
+            self.s3_client.put_object(
+                Bucket=BUCKET_NAME, Key=key, Body=data_json, ContentType="application/json"
+            )
+            print("✅ Learning data saved to R2")
+        except Exception as e:
+            print(f"❌ Failed to save learning data: {e}")
+
+    async def load_learning_data_async(self):
+        """تحميل بيانات التعلم"""
+        try:
+            key = "learning_data.json"
+            response = self.s3_client.get_object(Bucket=BUCKET_NAME, Key=key)
+            data = json.loads(response['Body'].read())
+            print("✅ Learning data loaded from R2")
+            return data
+        except ClientError as e:
+            if e.response['Error']['Code'] == 'NoSuchKey':
+                print("⚠️ No learning data found. Starting fresh.")
+                return {}
+            else:
+                raise
+
+    async def get_portfolio_state_async(self):
+        """Fetches the current portfolio state from R2, or initializes it."""
+        key = "portfolio_state.json"
+        try:
+            response = self.s3_client.get_object(Bucket=BUCKET_NAME, Key=key)
+            state = json.loads(response['Body'].read())
+            
+            if hasattr(self, '_portfolio_warning_printed'):
+                delattr(self, '_portfolio_warning_printed')
+                
+            print(f"💰 Portfolio state loaded: Current Capital ${state.get('current_capital_usd', 0):.2f}")
+            return state
+        except ClientError as e:
+            if e.response['Error']['Code'] == 'NoSuchKey':
+                if not hasattr(self, '_portfolio_warning_printed'):
+                    print(f"⚠️ No portfolio state file found. Initializing with ${INITIAL_CAPITAL:.2f}")
+                    self._portfolio_warning_printed = True
+                    
+                initial_state = {
+                    "current_capital_usd": INITIAL_CAPITAL,
+                    "invested_capital_usd": 0.0,
+                    "initial_capital_usd": INITIAL_CAPITAL,
+                    "total_trades": 0,
+                    "winning_trades": 0,
+                    "total_profit_usd": 0.0,
+                    "total_loss_usd": 0.0
+                }
+                await self.save_portfolio_state_async(initial_state)
+                return initial_state
+            else:
+                raise
+
+    async def save_portfolio_state_async(self, state):
+        """Saves the portfolio state to R2."""
+        key = "portfolio_state.json"
+        try:
+            data_json = json.dumps(state, indent=2).encode('utf-8')
+            self.s3_client.put_object(
+                Bucket=BUCKET_NAME, Key=key, Body=data_json, ContentType="application/json"
+            )
+            print(f"💾 Portfolio state saved: Current Capital ${state.get('current_capital_usd', 0):.2f}")
+        except Exception as e:
+            print(f"❌ Failed to save portfolio state: {e}")
+            raise
+
+    async def get_open_trades_async(self):
+        """Fetches all open trades from R2 with reduced noise."""
+        try:
+            response = self.s3_client.get_object(Bucket=BUCKET_NAME, Key="open_trades.json")
+            trades = json.loads(response['Body'].read())
+            
+            if hasattr(self, '_open_trades_warning_printed'):
+                delattr(self, '_open_trades_warning_printed')
+                
+            return trades
+        except ClientError as e:
+            if e.response['Error']['Code'] == 'NoSuchKey':
+                if not hasattr(self, '_open_trades_warning_printed'):
+                    print("⚠️ No open trades file found. Starting with an empty list.")
+                    print("💡 This is normal for first-time runs or when all trades are closed.")
+                    self._open_trades_warning_printed = True
+                return []
+            else:
+                raise
+    
+    async def save_open_trades_async(self, trades):
+        """Saves the list of open trades to R2."""
+        try:
+            data_json = json.dumps(trades, indent=2).encode('utf-8')
+            self.s3_client.put_object(
+                Bucket=BUCKET_NAME, Key="open_trades.json", Body=data_json, ContentType="application/json"
+            )
+            print(f"✅ Open trades saved to R2. Total open trades: {len(trades)}")
+        except Exception as e:
+            print(f"❌ Failed to save open trades: {e}")
+            raise
+
+    async def save_new_trade_async(self, symbol, decision, current_price):
+        """Creates a new trade using the full available capital and saves it."""
+        try:
+            portfolio_state = await self.get_portfolio_state_async()
+            available_capital = portfolio_state.get("current_capital_usd", 0)
+
+            if available_capital < 1:
+                print(f"❌ Insufficient capital (${available_capital:.2f}) to open a new trade.")
+                return
+
+            expected_target_minutes = decision.get('expected_target_minutes', 15)
+            expected_target_minutes = max(5, min(expected_target_minutes, 45))
+            expected_target_time = (datetime.now() + timedelta(minutes=expected_target_minutes)).isoformat()
+
+            # ✅ الإصلاح النهائي: التأكد من وجود استراتيجية صالحة
+            strategy = decision.get('strategy')
+            if not strategy or strategy == 'unknown':
+                strategy = 'GENERIC'
+                print(f"⚠️ Strategy was missing or unknown. Setting to GENERIC for {symbol}")
+
+            trades = await self.get_open_trades_async()
+            new_trade = {
+                "id": str(int(time.time())),
+                "symbol": symbol,
+                "entry_price": current_price,
+                "entry_timestamp": datetime.now().isoformat(),
+                "decision_data": decision,
+                "status": "OPEN",
+                "stop_loss": decision.get("stop_loss"),
+                "take_profit": decision.get("take_profit"),
+                "trade_type": decision.get("trade_type"),
+                "position_size_usd": available_capital,
+                "expected_target_minutes": expected_target_minutes,
+                "expected_target_time": expected_target_time,
+                "is_monitored": True,
+                "strategy": strategy  # ✅ استخدام الاستراتيجية المؤكدة
+            }
+            trades.append(new_trade)
+            await self.save_open_trades_async(trades)
+            
+            original_expected = decision.get('expected_target_minutes', 15)
+            if original_expected > 45:
+                print(f"⚠️ LLM wanted {original_expected} minutes, CAPPED to 45 minutes for strategy consistency")
+                
+            print(f"✅ New trade for {symbol} saved with position size ${available_capital:.2f}. Strategy: {strategy}. Expected results in {expected_target_minutes} minutes.")
+
+            portfolio_state["invested_capital_usd"] = available_capital
+            portfolio_state["current_capital_usd"] = 0.0
+            portfolio_state["total_trades"] = portfolio_state.get("total_trades", 0) + 1
+            await self.save_portfolio_state_async(portfolio_state)
+
+            await self.save_system_logs_async({
+                "new_trade_opened": True,
+                "symbol": symbol,
+                "position_size": available_capital,
+                "expected_minutes": expected_target_minutes,
+                "trade_type": decision.get("trade_type", "LONG"),
+                "strategy": strategy  # ✅ استخدام الاستراتيجية المؤكدة
+            })
+
+        except Exception as e:
+            print(f"❌ Failed to save new trade: {e}")
+            raise
+
+    async def update_trade_async(self, trade_to_update, re_analysis_decision):
+        """Updates an existing trade with new parameters from re-analysis."""
+        try:
+            if re_analysis_decision.get('new_stop_loss'):
+                trade_to_update['stop_loss'] = re_analysis_decision['new_stop_loss']
+            if re_analysis_decision.get('new_take_profit'):
+                trade_to_update['take_profit'] = re_analysis_decision['new_take_profit']
+            
+            new_expected_minutes = re_analysis_decision.get('new_expected_minutes')
+            if new_expected_minutes:
+                new_expected_minutes = max(5, min(new_expected_minutes, 45))
+                trade_to_update['expected_target_minutes'] = new_expected_minutes
+                trade_to_update['expected_target_time'] = (datetime.now() + timedelta(minutes=new_expected_minutes)).isoformat()
+                print(f"⏰ Trade time expectation updated to {new_expected_minutes} minutes.")
+
+            # ✅ الإصلاح: الحفاظ على الاستراتيجية الأصلية
+            original_strategy = trade_to_update.get('strategy')
+            if not original_strategy or original_strategy == 'unknown':
+                original_strategy = re_analysis_decision.get('strategy', 'GENERIC')
+            
+            trade_to_update['strategy'] = original_strategy
+            trade_to_update['decision_data'] = re_analysis_decision
+            trade_to_update['is_monitored'] = True
+
+            open_trades = await self.get_open_trades_async()
+            for i, trade in enumerate(open_trades):
+                if trade.get('id') == trade_to_update.get('id'):
+                    open_trades[i] = trade_to_update
+                    break
+
+            await self.save_open_trades_async(open_trades)
+            print(f"✅ Trade for {trade_to_update.get('symbol')} updated successfully. Strategy: {original_strategy}")
+
+            await self.save_system_logs_async({
+                "trade_updated": True,
+                "symbol": trade_to_update.get('symbol'),
+                "new_expected_minutes": new_expected_minutes,
+                "action": "UPDATE_TRADE",
+                "strategy": original_strategy
+            })
+
+        except Exception as e:
+            print(f"❌ Failed to update trade: {e}")
+            raise
+
+    async def immediate_close_trade_async(self, symbol, close_price, reason="Real-time monitoring"):
+        """Closes a trade immediately without full re-analysis."""
+        try:
+            open_trades = await self.get_open_trades_async()
+            trade_to_close = None
+            
+            for trade in open_trades:
+                if trade['symbol'] == symbol and trade['status'] == 'OPEN':
+                    trade_to_close = trade
+                    break
+            
+            if not trade_to_close:
+                print(f"❌ No open trade found for {symbol}")
+                return False
+            
+            await self.close_trade_async(trade_to_close, close_price)
+            print(f"🚨 IMMEDIATE CLOSE: {symbol} at {close_price} - {reason}")
+            
+            await self.save_system_logs_async({
+                "immediate_close": True,
+                "symbol": symbol,
+                "close_price": close_price,
+                "reason": reason,
+                "strategy": trade_to_close.get('strategy', 'unknown')
+            })
+            
+            return True
+            
+        except Exception as e:
+            print(f"❌ Failed to immediately close trade {symbol}: {e}")
+            return False
+
+    async def _archive_closed_trade_async(self, closed_trade):
+        """Appends a closed trade to the history file."""
+        key = "closed_trades_history.json"
+        try:
+            response = self.s3_client.get_object(Bucket=BUCKET_NAME, Key=key)
+            history = json.loads(response['Body'].read())
+        except ClientError as e:
+            if e.response['Error']['Code'] == 'NoSuchKey':
+                history = []
+            else:
+                raise
+        
+        history.append(closed_trade)
+        
+        data_json = json.dumps(history, indent=2).encode('utf-8')
+        self.s3_client.put_object(
+            Bucket=BUCKET_NAME, Key=key, Body=data_json, ContentType="application/json"
+        )
+        print(f"📚 Trade archived. Total archived trades: {len(history)}")
+
+    async def _update_trade_summary_async(self, closed_trade):
+        """Updates the trade summary statistics file."""
+        key = "trade_summary.json"
+        try:
+            try:
+                response = self.s3_client.get_object(Bucket=BUCKET_NAME, Key=key)
+                summary = json.loads(response['Body'].read())
+            except ClientError as e:
+                if e.response['Error']['Code'] == 'NoSuchKey':
+                    summary = {
+                        "total_trades": 0, "winning_trades": 0, "losing_trades": 0,
+                        "total_profit_usd": 0.0, "total_loss_usd": 0.0, "win_percentage": 0.0,
+                        "avg_profit_per_trade": 0.0, "avg_loss_per_trade": 0.0,
+                        "largest_win": 0.0, "largest_loss": 0.0
+                    }
+                else:
+                    raise
+            
+            pnl = closed_trade.get('pnl_usd', 0.0)
+            
+            summary['total_trades'] += 1
+            if pnl >= 0:
+                summary['winning_trades'] += 1
+                summary['total_profit_usd'] += pnl
+                if pnl > summary.get('largest_win', 0):
+                    summary['largest_win'] = pnl
+            else:
+                summary['losing_trades'] += 1
+                summary['total_loss_usd'] += abs(pnl)
+                if abs(pnl) > summary.get('largest_loss', 0):
+                    summary['largest_loss'] = abs(pnl)
+            
+            if summary['total_trades'] > 0:
+                summary['win_percentage'] = (summary['winning_trades'] / summary['total_trades']) * 100
+            
+            if summary['winning_trades'] > 0:
+                summary['avg_profit_per_trade'] = summary['total_profit_usd'] / summary['winning_trades']
+            if summary['losing_trades'] > 0:
+                summary['avg_loss_per_trade'] = summary['total_loss_usd'] / summary['losing_trades']
+            
+            data_json = json.dumps(summary, indent=2).encode('utf-8')
+            self.s3_client.put_object(
+                Bucket=BUCKET_NAME, Key=key, Body=data_json, ContentType="application/json"
+            )
+            print(f"📊 Trade summary updated. Win Rate: {summary['win_percentage']:.2f}%")
+
+        except Exception as e:
+            print(f"❌ Failed to update trade summary: {e}")
+            raise
+
+    async def load_contracts_db_async(self):
+        """Loads the contracts database from R2 with reduced noise."""
+        key = "contracts.json"
+        try:
+            response = self.s3_client.get_object(Bucket=BUCKET_NAME, Key=key)
+            contracts_db = json.loads(response['Body'].read())
+            
+            if hasattr(self, '_contracts_warning_printed'):
+                delattr(self, '_contracts_warning_printed')
+                
+            print(f"💾 Contracts database loaded from R2. Total entries: {len(contracts_db)}")
+            return contracts_db
+        except ClientError as e:
+            if e.response['Error']['Code'] == 'NoSuchKey':
+                if not hasattr(self, '_contracts_warning_printed'):
+                    print("⚠️ No existing contracts database found. Initializing new one.")
+                    self._contracts_warning_printed = True
+                return {}
+            else:
+                raise
+    
+    async def save_contracts_db_async(self, data):
+        """Saves the contracts database to R2."""
+        key = "contracts.json"
+        try:
+            data_json = json.dumps(data, indent=2).encode('utf-8')
+            self.s3_client.put_object(
+                Bucket=BUCKET_NAME, Key=key, Body=data_json, ContentType="application/json"
+            )
+            print(f"✅ Contracts database saved to R2 successfully. Total entries: {len(data)}")
+        except Exception as e:
+            print(f"❌ Failed to save contracts database to R2: {e}")
+            raise
+
+    async def get_trade_by_symbol_async(self, symbol):
+        """Fetches a specific trade by symbol."""
+        try:
+            open_trades = await self.get_open_trades_async()
+            for trade in open_trades:
+                if trade['symbol'] == symbol and trade['status'] == 'OPEN':
+                    return trade
+            return None
+        except Exception as e:
+            print(f"❌ Failed to get trade by symbol {symbol}: {e}")
+            return None
+
+    async def update_trade_monitoring_status_async(self, symbol, is_monitored):
+        """Updates the monitoring status of a trade."""
+        try:
+            open_trades = await self.get_open_trades_async()
+            updated = False
+            
+            for trade in open_trades:
+                if trade['symbol'] == symbol:
+                    trade['is_monitored'] = is_monitored
+                    updated = True
+                    break
+            
+            if updated:
+                await self.save_open_trades_async(open_trades)
+                status = "ENABLED" if is_monitored else "DISABLED"
+                print(f"✅ Real-time monitoring {status} for {symbol}")
+            else:
+                print(f"⚠️ Trade {symbol} not found for monitoring status update")
+                
+            return updated
+            
+        except Exception as e:
+            print(f"❌ Failed to update monitoring status for {symbol}: {e}")
+            return False
+
+    async def get_monitored_trades_async(self):
+        """Fetches all trades that are currently being monitored."""
+        try:
+            open_trades = await self.get_open_trades_async()
+            monitored_trades = [trade for trade in open_trades if trade.get('is_monitored', False)]
+            return monitored_trades
+        except Exception as e:
+            print(f"❌ Failed to get monitored trades: {e}")
+            return []
+
+print("✅ Enhanced R2 Service Loaded - Comprehensive Logging System with Learning Support")