Update data_manager.py

data_manager.py

@@ -8,8 +8,8 @@ from datetime import datetime
 import ccxt.pro as ccxt
 import numpy as np
 import logging
+from typing import List, Dict, Any
 
-# تعطيل تسجيل HTTP المزعج فقط
 logging.getLogger("httpx").setLevel(logging.WARNING)
 logging.getLogger("httpcore").setLevel(logging.WARNING)
 
@@ -31,33 +31,15 @@ class DataManager:
             print(f"❌ فشل تهيئة اتصال KuCoin: {e}")
             self.exchange = None
             
-        self._whale_data_cache = {}
         self.http_client = None
-        self.fetch_stats = {'successful_fetches': 0, 'failed_fetches': 0, 'rate_limit_hits': 0}
-        self.price_cache = {}
         self.market_cache = {}
         self.last_market_load = None
         
-        self.price_sources = {
-            'kucoin': self._get_prices_from_kucoin_safe,
-            'coingecko': self._get_prices_from_coingecko
-        }
-    
     async def initialize(self):
         self.http_client = httpx.AsyncClient(timeout=20.0)
-        
-        api_status = {
-            'KUCOIN': '🟢 عام (بدون مفتاح)',
-            'MORALIS_KEY': "🟢 متوفر" if os.getenv('MORALIS_KEY') else "🔴 غير متوفر",
-            'ETHERSCAN_KEY': "🟢 متوفر" if os.getenv('ETHERSCAN_KEY') else "🔴 غير متوفر", 
-            'INFURA_KEY': "🟢 متوفر" if os.getenv('INFURA_KEY') else "🔴 غير متوفر"
-        }
-        
-        for key, status in api_status.items():
-            print(f"   {key}: {status}")
-        
         await self._load_markets()
-    
+        print("✅ DataManager initialized - Focused on data retrieval only")
+
     async def _load_markets(self):
         try:
             if not self.exchange:
@@ -78,232 +60,78 @@ class DataManager:
         if self.exchange:
             await self.exchange.close()
 
-    async def get_native_coin_price(self, network):
-        now = time.time()
-        cache_key = f"{network}_price"
-        
-        if cache_key in self.price_cache and (now - self.price_cache[cache_key]['timestamp']) < 300:
-            return self.price_cache[cache_key]['price']
-
-        symbol_map = {
-            'ethereum': 'ETH',
-            'bsc': 'BNB',
-            'bitcoin': 'BTC'
-        }
-        
-        symbol = symbol_map.get(network)
-        if not symbol:
-            return await self._get_price_from_coingecko_fallback(network)
-
-        try:
-            price = await self._get_price_from_kucoin(symbol)
-            if price and price > 0:
-                self.price_cache[cache_key] = {'price': price, 'timestamp': now, 'source': 'kucoin'}
-                return price
-                
-            price = await self._get_price_from_coingecko_fallback(network)
-            if price and price > 0:
-                self.price_cache[cache_key] = {'price': price, 'timestamp': now, 'source': 'coingecko'}
-                return price
-                
-            return None
-            
-        except Exception as e:
-            print(f"❌ فشل جلب سعر {network}: {e}")
-            return None
-
-    async def _get_price_from_kucoin(self, symbol):
-        if not self.exchange:
-            return None
-            
+    async def get_market_context_async(self):
+        """جلب سياق السوق الأساسي فقط"""
         try:
-            trading_symbol = f"{symbol}/USDT"
+            sentiment_data = await self.get_sentiment_safe_async()
+            price_data = await self._get_prices_with_fallback()
+            
+            bitcoin_price = price_data.get('bitcoin')
+            ethereum_price = price_data.get('ethereum')
+            
+            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 'NEUTRAL',
+                'market_trend': self._determine_market_trend(bitcoin_price, sentiment_data),
+                'btc_sentiment': self._get_btc_sentiment(bitcoin_price),
+                'data_quality': 'HIGH' if bitcoin_price and ethereum_price else 'LOW'
+            }
             
-            if trading_symbol not in self.market_cache:
-                print(f"⚠️ السوق {trading_symbol} غير متوفر في KuCoin")
-                return None
+            return market_context
                 
-            ticker = await self.exchange.fetch_ticker(trading_symbol)
-            price = ticker.get('last')
-            if price and price > 0:
-                return float(price)
-            else:
-                print(f"⚠️ لم يتم العثور على سعر صالح لـ {symbol}")
-                return None
-            
         except Exception as e:
-            print(f"❌ فشل جلب سعر {symbol} من KuCoin: {e}")
-            return None
-
-    async def _get_price_from_coingecko_fallback(self, network):
-        coin_map = {
-            'ethereum': 'ethereum', 
-            'bsc': 'binancecoin',
-            'bitcoin': 'bitcoin'
-        }
-        
-        coin_id = coin_map.get(network)
-        if not coin_id: 
-            return None
+            print(f"❌ فشل جلب سياق السوق: {e}")
+            return self._get_minimal_market_context()
 
+    async def get_sentiment_safe_async(self):
+        """جلب بيانات المشاعر"""
         try:
-            await asyncio.sleep(0.5)
-            url = f"https://api.coingecko.com/api/v3/simple/price?ids={coin_id}&vs_currencies=usd"
-            async with httpx.AsyncClient() as client:
-                response = await client.get(url, timeout=10)
+            async with httpx.AsyncClient(timeout=8) as client:
+                response = await client.get("https://api.alternative.me/fng/")
                 response.raise_for_status()
                 data = response.json()
                 
-                price = data.get(coin_id, {}).get('usd')
-                if price and price > 0:
-                    print(f"✅ سعر {network.upper()} (CoinGecko): ${price:,.2f}")
-                    return price
-                else:
-                    print(f"⚠️ لم يتم العثور على سعر {network} في CoinGecko")
-                    return None
-                    
-        except Exception as e:
-            print(f"❌ فشل جلب سعر {network} من CoinGecko: {e}")
-            return None
-
-    async def get_sentiment_safe_async(self):
-        max_retries = 2
-        for attempt in range(max_retries):
-            try:
-                async with httpx.AsyncClient(timeout=8) 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]
-                    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}): {e}")
-                if attempt < max_retries - 1:
-                    await asyncio.sleep(1)
-        
-        return None
-
-    async def get_market_context_async(self):
-        max_retries = 2
-        for attempt in range(max_retries):
-            try:
-                sentiment_task = asyncio.wait_for(self.get_sentiment_safe_async(), timeout=10)
-                price_task = asyncio.wait_for(self._get_prices_with_fallback(), timeout=15)
-                
-                results = await asyncio.gather(sentiment_task, price_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 {}
-
-                bitcoin_price = price_data.get('bitcoin')
-                ethereum_price = price_data.get('ethereum')
+                if 'data' not in data or not data['data']:
+                    raise ValueError("بيانات المشاعر غير متوفرة")
                 
-                if bitcoin_price is None or ethereum_price is None:
-                    if attempt < max_retries - 1:
-                        await asyncio.sleep(2)
-                        continue
-                    else:
-                        return self._get_minimal_market_context()
-
-                market_trend = self._determine_market_trend(bitcoin_price, sentiment_data)
-                
-                trading_decision = self._analyze_market_trading_signals(sentiment_data)
-                
-                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 'UNKNOWN',
-                    'general_whale_activity': {
-                        'data_available': False,
-                        'description': 'نظام الحيتان العام معطل - يركز النظام على تحليل الحيتان للعملات المرشحة فقط',
-                        'critical_alert': False,
-                        'sentiment': 'NEUTRAL',
-                        'trading_signals': []
-                    },
-                    'market_trend': market_trend,
-                    'trading_decision': trading_decision,
-                    'btc_sentiment': self._get_btc_sentiment(bitcoin_price),
-                    'data_sources': {
-                        'prices': bitcoin_price is not None and ethereum_price is not None,
-                        'sentiment': sentiment_data is not None,
-                        'general_whale_data': False,
-                        'netflow_analysis': 'DISABLED'
-                    },
-                    'data_quality': 'HIGH',
-                    'risk_assessment': self._assess_market_risk(sentiment_data)
+                latest_data = data['data'][0]
+                return {
+                    "feargreed_value": int(latest_data['value']), 
+                    "feargreed_class": latest_data['value_classification'],
+                    "source": "alternative.me",
+                    "timestamp": datetime.now().isoformat()
                 }
-                
-                return market_context
-                
-            except Exception as e:
-                print(f"❌ فشل جلب سياق السوق (المحاولة {attempt + 1}): {e}")
-                if attempt < max_retries - 1:
-                    await asyncio.sleep(3)
-
-        return self._get_minimal_market_context()
+        except Exception as e:
+            print(f"❌ فشل جلب بيانات المشاعر: {e}")
+            return None
 
-    def _analyze_market_trading_signals(self, sentiment_data):
-        """تحليل إشارات التداول بناءً على مشاعر السوق فقط"""
-        if not sentiment_data:
-            return {
-                'action': 'HOLD',
-                'confidence': 0.0,
-                'reason': 'غير متوفر - لا توجد بيانات كافية عن مشاعر السوق',
-                'risk_level': 'UNKNOWN'
-            }
-        
-        fear_greed = sentiment_data.get('feargreed_value', 50)
-        sentiment_class = sentiment_data.get('feargreed_class', 'NEUTRAL')
+    def _determine_market_trend(self, bitcoin_price, sentiment_data):
+        """تحديد اتجاه السوق"""
+        if bitcoin_price is None:
+            return "UNKNOWN"
         
-        if fear_greed <= 25:
-            return {
-                'action': 'BUY',
-                'confidence': 0.7,
-                'reason': f'مستوى خوف مرتفع في السوق: {fear_greed} - فرصة شرائية',
-                'risk_level': 'LOW'
-            }
-        elif fear_greed >= 75:
-            return {
-                'action': 'SELL',
-                'confidence': 0.6,
-                'reason': f'مستوى جشع مرتفع في السوق: {fear_greed} - احتياط بيعي',
-                'risk_level': 'MEDIUM'
-            }
-        else:
-            return {
-                'action': 'HOLD',
-                'confidence': 0.5,
-                'reason': f'مشاعر السوق متوازنة: {sentiment_class} ({fear_greed})',
-                'risk_level': 'LOW'
-            }
-
-    def _assess_market_risk(self, sentiment_data):
-        """تقييم مخاطر السوق بناءً على المشاعر فقط"""
-        risk_factors = []
-        risk_score = 0
+        score = 0
+        if bitcoin_price > 60000: 
+            score += 1
+        elif bitcoin_price < 55000: 
+            score -= 1
         
-        if sentiment_data and sentiment_data.get('feargreed_value', 50) < 30:
-            risk_factors.append("مخاوف السوق عالية")
-            risk_score += 2
-        elif sentiment_data and sentiment_data.get('feargreed_value', 50) > 70:
-            risk_factors.append("جشع السوق مرتفع")
-            risk_score += 1
+        if sentiment_data and sentiment_data.get('feargreed_value') is not None:
+            fear_greed = sentiment_data.get('feargreed_value')
+            if fear_greed > 60: 
+                score += 1
+            elif fear_greed < 40: 
+                score -= 1
         
-        if risk_score >= 2:
-            return {'level': 'MEDIUM', 'score': risk_score, 'factors': risk_factors}
+        if score >= 1: 
+            return "bull_market"
+        elif score <= -1: 
+            return "bear_market"
         else:
-            return {'level': 'LOW', 'score': risk_score, 'factors': risk_factors}
+            return "sideways_market"
 
     def _get_btc_sentiment(self, bitcoin_price):
         if bitcoin_price is None:
@@ -316,17 +144,12 @@ class DataManager:
             return 'NEUTRAL'
 
     async def _get_prices_with_fallback(self):
+        """جلب أسعار البيتكوين والإيثيريوم"""
         try:
             prices = await self._get_prices_from_kucoin_safe()
             if prices.get('bitcoin') and prices.get('ethereum'):
                 return prices
-                
-            prices = await self._get_prices_from_coingecko()
-            if prices.get('bitcoin') and prices.get('ethereum'):
-                return prices
-                
-            return {'bitcoin': None, 'ethereum': None}
-            
+            return await self._get_prices_from_coingecko()
         except Exception as e:
             print(f"❌ فشل جلب الأسعار: {e}")
             return {'bitcoin': None, 'ethereum': None}
@@ -338,37 +161,24 @@ class DataManager:
         try:
             prices = {'bitcoin': None, 'ethereum': None}
             
-            try:
-                btc_ticker = await self.exchange.fetch_ticker('BTC/USDT')
-                btc_price = float(btc_ticker.get('last', 0)) if btc_ticker.get('last') else None
-                if btc_price and btc_price > 0:
-                    prices['bitcoin'] = btc_price
-                    self.price_cache['bitcoin'] = btc_price
-                    print(f"✅ سعر BTC: ${btc_price:,.2f}")
-                else:
-                    print("⚠️ لم يتم العثور على سعر BTC صالح")
-            except Exception as e:
-                print(f"❌ فشل جلب سعر BTC: {e}")
+            btc_ticker = await self.exchange.fetch_ticker('BTC/USDT')
+            btc_price = float(btc_ticker.get('last', 0)) if btc_ticker.get('last') else None
+            if btc_price and btc_price > 0:
+                prices['bitcoin'] = btc_price
             
-            try:
-                eth_ticker = await self.exchange.fetch_ticker('ETH/USDT')
-                eth_price = float(eth_ticker.get('last', 0)) if eth_ticker.get('last') else None
-                if eth_price and eth_price > 0:
-                    prices['ethereum'] = eth_price
-                    self.price_cache['ethereum'] = eth_price
-                    print(f"✅ سعر ETH: ${eth_price:,.2f}")
-                else:
-                    print("⚠️ لم يتم العثور على سعر ETH صالح")
-            except Exception as e:
-                print(f"❌ فشل جلب سعر ETH: {e}")
+            eth_ticker = await self.exchange.fetch_ticker('ETH/USDT')
+            eth_price = float(eth_ticker.get('last', 0)) if eth_ticker.get('last') else None
+            if eth_price and eth_price > 0:
+                prices['ethereum'] = eth_price
             
             return prices
             
         except Exception as e:
-            print(f"❌ خطأ في _get_prices_from_kucoin_safe: {e}")
+            print(f"❌ خطأ في جلب الأسعار من KuCoin: {e}")
             return {'bitcoin': None, 'ethereum': None}
 
     async def _get_prices_from_coingecko(self):
+        """الاحتياطي: جلب الأسعار من CoinGecko"""
         try:
             await asyncio.sleep(0.5)
             url = "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,ethereum&vs_currencies=usd"
@@ -381,13 +191,8 @@ class DataManager:
                 eth_price = data.get('ethereum', {}).get('usd')
                 
                 if btc_price and eth_price:
-                    self.price_cache['bitcoin'] = btc_price
-                    self.price_cache['ethereum'] = eth_price
-                    print(f"✅ سعر BTC (CoinGecko): ${btc_price:,.2f}")
-                    print(f"✅ سعر ETH (CoinGecko): ${eth_price:,.2f}")
                     return {'bitcoin': btc_price, 'ethereum': eth_price}
                 else:
-                    print("⚠️ لم يتم العثور على أسعار صالحة من CoinGecko")
                     return {'bitcoin': None, 'ethereum': None}
                     
         except Exception as e:
@@ -395,593 +200,270 @@ class DataManager:
             return {'bitcoin': None, 'ethereum': None}
 
     def _get_minimal_market_context(self):
+        """سياق سوق بدائي عند الفشل"""
         return {
             'timestamp': datetime.now().isoformat(),
             'data_available': False,
-            'data_sources': {'prices': False, 'sentiment': False, 'general_whale_data': False},
-            'error': 'غير متوفر - فشل في جلب بيانات السوق من المصادر الخارجية',
             'market_trend': 'UNKNOWN',
             'btc_sentiment': 'UNKNOWN',
-            'data_quality': 'LOW',
-            'general_whale_activity': {
-                'data_available': False,
-                'description': 'نظام الحيتان العام معطل - يركز النظام على تحليل الحيتان للعملات المرشحة فقط',
-                'critical_alert': False,
-                'sentiment': 'NEUTRAL'
-            },
-            'bitcoin_price_usd': None,
-            'ethereum_price_usd': None,
-            'fear_and_greed_index': None,
-            'sentiment_class': 'UNKNOWN',
-            'missing_data': ['غير متوفر - أسعار البيتكوين', 'غير متوفر - أسعار الإيثيريوم', 'غير متوفر - بيانات المشاعر']
+            'data_quality': 'LOW'
         }
 
-    def _determine_market_trend(self, bitcoin_price, sentiment_data):
-        """تحديد اتجاه السوق بدون بيانات الحيتان العامة"""
-        try:
-            if bitcoin_price is None:
-                return "UNKNOWN"
-            
-            score = 0
-            data_points = 1
+    async def layer1_rapid_screening(self) -> List[Dict[str, Any]]:
+        """
+        الطبقة 1: فحص سريع لجميع عملات KuCoin
+        يركز فقط على جلب البيانات الأساسية بدون تحليل متقدم
+        """
+        candidates = []
+        
+        # الحصول على جميع الرموز النشطة
+        usdt_symbols = [
+            symbol for symbol in self.market_cache.keys() 
+            if symbol.endswith('/USDT') and self.market_cache[symbol].get('active', False)
+        ]
+        
+        print(f"📊 الطبقة 1: فحص سريع لـ {len(usdt_symbols)} عملة في KuCoin...")
+        
+        batch_size = 50
+        for i in range(0, len(usdt_symbols), batch_size):
+            batch = usdt_symbols[i:i + batch_size]
+            print(f"   🔍 معالجة مجموعة {i//batch_size + 1}/{(len(usdt_symbols)//batch_size)+1}...")
             
-            if bitcoin_price > 60000: 
-                score += 1
-            elif bitcoin_price < 55000: 
-                score -= 1
+            batch_candidates = await self._process_batch_rapid_screening(batch)
+            candidates.extend(batch_candidates)
             
-            if sentiment_data and sentiment_data.get('feargreed_value') is not None:
-                fear_greed = sentiment_data.get('feargreed_value')
-                if fear_greed > 60: 
-                    score += 1
-                elif fear_greed < 40: 
-                    score -= 1
-                data_points += 1
+            await asyncio.sleep(1)
         
-            if data_points < 2:
-                return "UNKNOWN"
-            
-            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:
-            return "UNKNOWN"
-
-    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
+        # ترتيب المرشحين حسب قوة الأساسيات
+        candidates.sort(key=lambda x: x.get('layer1_score', 0), reverse=True)
         
-        stats = {
-            '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(),
-            'exchange_available': self.exchange is not None,
-            'markets_loaded': len(self.market_cache) if self.market_cache else 0,
-            'last_market_load': self.last_market_load.isoformat() if self.last_market_load else None
-        }
+        # نأخذ أفضل 80-180 مرشح للطبقة 2
+        target_count = min(max(80, len(candidates) // 5), 180)
+        final_candidates = candidates[:target_count]
         
-        stats['api_usage'] = {
-            'note': 'نظام الحيتان العام معطل - يتم تحليل الحيتان للعملات المرشحة فقط'
-        }
+        print(f"✅ تم اختيار {len(final_candidates)} عملة من الطبقة 1")
+        
+        # عرض أفضل 5 مرشحين
+        print("   🏆 أفضل 5 مرشحين من الطبقة 1:")
+        for i, candidate in enumerate(final_candidates[:5]):
+            score = candidate.get('layer1_score', 0)
+            volume = candidate.get('dollar_volume', 0)
+            change = candidate.get('price_change_24h', 0)
+            print(f"      {i+1}. {candidate['symbol']}: {score:.3f} | ${volume:,.0f} | {change:+.1f}%")
         
-        return stats
+        return final_candidates
 
-    async def get_symbol_specific_whale_data(self, symbol, contract_address=None):
-        """جلب بيانات الحيتان الخاصة برمز معين"""
-        if hasattr(self.whale_monitor, 'get_symbol_whale_activity'):
-            return await self.whale_monitor.get_symbol_whale_activity(symbol, contract_address)
+    async def _process_batch_rapid_screening(self, symbols_batch: List[str]) -> List[Dict[str, Any]]:
+        """معالجة دفعة من الرموز في الطبقة 1"""
+        candidates = []
+        
+        for symbol in symbols_batch:
+            try:
+                # جلب بيانات التداول الأساسية فقط
+                ticker = await self.exchange.fetch_ticker(symbol)
+                if not ticker:
+                    continue
+                
+                current_price = ticker.get('last', 0)
+                volume_24h = ticker.get('baseVolume', 0)
+                dollar_volume = volume_24h * current_price
+                price_change_24h = ticker.get('percentage', 0)
+                high_24h = ticker.get('high', 0)
+                low_24h = ticker.get('low', 0)
+                
+                # المعايير الأساسية المطلوبة
+                meets_criteria = all([
+                    dollar_volume >= 1000000,      # حجم تداول لا يقل عن 1M دولار
+                    current_price > 0.00000001,   # أي سعر مقبول
+                    current_price <= 100000,      # حد أقصى معقول
+                    high_24h > 0,                 # بيانات سعر صالحة
+                    low_24h > 0
+                ])
+                
+                if not meets_criteria:
+                    continue
+                
+                # حساب مؤشرات أساسية بسيطة فقط
+                volume_strength = self._calculate_volume_strength(dollar_volume)
+                price_momentum = self._calculate_price_momentum(price_change_24h)
+                price_position = self._calculate_price_position(current_price, high_24h, low_24h)
+                volatility = self._calculate_volatility(high_24h, low_24h, current_price)
+                
+                # الدرجة النهائية للطبقة 1 (أساسيات فقط)
+                layer1_score = (
+                    volume_strength * 0.35 +
+                    price_momentum * 0.30 +
+                    price_position * 0.20 +
+                    volatility * 0.15
+                )
+                
+                if layer1_score >= 0.3:
+                    candidate_data = {
+                        'symbol': symbol,
+                        'current_price': current_price,
+                        'volume_24h': volume_24h,
+                        'dollar_volume': dollar_volume,
+                        'price_change_24h': price_change_24h,
+                        'high_24h': high_24h,
+                        'low_24h': low_24h,
+                        'layer1_score': layer1_score,
+                        'volume_strength': volume_strength,
+                        'price_momentum': price_momentum,
+                        'reasons': self._generate_layer1_reasons(volume_strength, price_momentum, dollar_volume, price_change_24h)
+                    }
+                    
+                    candidates.append(candidate_data)
+                    
+            except Exception as e:
+                if "rate limit" not in str(e).lower():
+                    continue
+        
+        return candidates
+
+    def _calculate_volume_strength(self, dollar_volume: float) -> float:
+        """حساب قوة الحجم (بيانات فقط)"""
+        if dollar_volume >= 10000000:
+            return 1.0
+        elif dollar_volume >= 5000000:
+            return 0.8
+        elif dollar_volume >= 2000000:
+            return 0.6
+        elif dollar_volume >= 1000000:
+            return 0.4
         else:
-            return {
-                'data_available': False,
-                'error': 'نظام تحليل الحيتان غير متوفر',
-                'symbol': symbol
-            }
+            return 0.2
+
+    def _calculate_price_momentum(self, price_change_24h: float) -> float:
+        """حساب زخم السعر (بيانات فقط)"""
+        if price_change_24h >= 15:
+            return 0.9
+        elif price_change_24h >= 8:
+            return 0.7
+        elif price_change_24h >= 3:
+            return 0.5
+        elif price_change_24h <= -15:
+            return 0.8
+        elif price_change_24h <= -8:
+            return 0.6
+        elif price_change_24h <= -3:
+            return 0.4
+        else:
+            return 0.3
 
-    async def get_whale_trading_signal(self, symbol, whale_data, market_context):
-        """جلب إشارة تداول بناءً على بيانات الحيتان للرمز المحدد"""
-        if hasattr(self.whale_monitor, 'generate_whale_trading_signal'):
-            return await self.whale_monitor.generate_whale_trading_signal(symbol, whale_data, market_context)
+    def _calculate_price_position(self, current_price: float, high_24h: float, low_24h: float) -> float:
+        """حساب موقع السعر (بيانات فقط)"""
+        if high_24h == low_24h:
+            return 0.5
+        
+        position = (current_price - low_24h) / (high_24h - low_24h)
+        
+        if position < 0.3:
+            return 0.8
+        elif position > 0.7:
+            return 0.6
         else:
-            return {
-                'action': 'HOLD',
-                'confidence': 0.3,
-                'reason': 'نظام تحليل الحيتان غير متوفر',
-                'source': 'whale_analysis'
-            }
+            return 0.5
 
-    async def _calculate_technical_score(self, symbol, ohlcv_data):
-        """
-        حساب درجة ��قنية شاملة تعتمد على:
-        - الزخم السعري (قصير ومتوسط المدى)
-        - السيولة والحجم
-        - قوة الاتجاه
-        - التقلب
-        - الزخم الحجمي
-        """
-        try:
-            if not ohlcv_data or '1h' not in ohlcv_data:
-                return 0.0
-            
-            hourly_data = ohlcv_data['1h']
-            if len(hourly_data) < 50:
-                return 0.0
-            
-            closes = np.array([candle[4] for candle in hourly_data])
-            volumes = np.array([candle[5] for candle in hourly_data])
-            highs = np.array([candle[2] for candle in hourly_data])
-            lows = np.array([candle[3] for candle in hourly_data])
-            opens = np.array([candle[1] for candle in hourly_data])
-            
-            current_price = closes[-1]
-            
-            # 1. تقييم الزخم السعري (Momentum) - الوزن الأكبر
-            momentum_score = 0.0
-            
-            # زخم قصير المدى (1-4 ساعات)
-            if len(closes) >= 5:
-                price_change_1h = ((closes[-1] - closes[-2]) / closes[-2]) * 100
-                price_change_4h = ((closes[-1] - closes[-5]) / closes[-5]) * 100
-                
-                # نفضل الزخم الإيجابي المعتدل (2%-10%)
-                if 2 <= price_change_1h <= 10:
-                    momentum_score += 0.3
-                elif 2 <= price_change_4h <= 15:
-                    momentum_score += 0.2
-                
-                # زخم متوسط المدى (12-24 ساعة)
-                if len(closes) >= 25:
-                    price_change_12h = ((closes[-1] - closes[-13]) / closes[-13]) * 100
-                    price_change_24h = ((closes[-1] - closes[-25]) / closes[-25]) * 100
-                    
-                    if 5 <= price_change_12h <= 20:
-                        momentum_score += 0.2
-                    if 8 <= price_change_24h <= 25:
-                        momentum_score += 0.2
-            
-            # 2. تقييم السيولة والحجم (Liquidity & Volume)
-            liquidity_score = 0.0
-            
-            # متوسط الحجم بالدولار
-            avg_dollar_volume = np.mean(volumes[-50:]) * np.mean(closes[-50:])
-            if avg_dollar_volume > 1000000:  # أكثر من 1 مليون دولار
-                liquidity_score += 0.4
-            elif avg_dollar_volume > 500000:  # أكثر من 500 ألف دولار
-                liquidity_score += 0.3
-            elif avg_dollar_volume > 100000:  # أكثر من 100 ألف دولار
-                liquidity_score += 0.2
-            
-            # نسبة الحجم الحديث إلى المتوسط
-            recent_volume = np.mean(volumes[-6:])  # آخر 6 ساعات
-            avg_volume_50 = np.mean(volumes[-50:])
-            volume_ratio = recent_volume / avg_volume_50 if avg_volume_50 > 0 else 1.0
-            
-            if volume_ratio > 1.5:  # حجم مرتفع حديثاً
-                liquidity_score += 0.3
-            elif volume_ratio > 1.2:
-                liquidity_score += 0.2
-            
-            # 3. تقييم قوة الاتجاه (Trend Strength)
-            trend_score = 0.0
-            
-            if len(closes) >= 20:
-                # المتوسطات المتحركة
-                ma_short = np.mean(closes[-5:])   # 5 ساعات
-                ma_medium = np.mean(closes[-13:]) # 13 ساعة
-                ma_long = np.mean(closes[-21:])   # 21 ساعة
-                
-                # تأكيد الاتجاه (جميع المتوسطات في نفس الاتجاه)
-                if ma_short > ma_medium > ma_long:
-                    trend_score += 0.4  # اتجاه صاعد قوي
-                elif ma_short < ma_medium < ma_long:
-                    trend_score += 0.2  # اتجاه هابط
-                
-                # قوة الاتجاه (المسافة بين المتوسطات)
-                trend_strength = (ma_short - ma_long) / ma_long * 100
-                if abs(trend_strength) > 3:  # اتجاه قوي (>3%)
-                    trend_score += 0.2
-            
-            # 4. تقييم التقلب (Volatility) - نفضل التقلب المعتدل
-            volatility_score = 0.0
-            
-            true_ranges = []
-            for i in range(1, len(hourly_data)):
-                high, low, prev_close = highs[i], lows[i], closes[i-1]
-                tr1 = high - low
-                tr2 = abs(high - prev_close)
-                tr3 = abs(low - prev_close)
-                true_ranges.append(max(tr1, tr2, tr3))
-            
-            if true_ranges:
-                atr = np.mean(true_ranges[-14:])
-                atr_percent = (atr / current_price) * 100
-                
-                # نفضل التقلب بين 2% و 8% (فرص تداول جيدة)
-                if 2 <= atr_percent <= 8:
-                    volatility_score = 0.3
-                elif atr_percent > 8:
-                    volatility_score = 0.1  # تقلب عالي خطير
-                else:
-                    volatility_score = 0.1  # تقلب منخفض قليل الفرص
-            
-            # 5. تقييم الزخم الحجمي (Volume Momentum)
-            volume_momentum_score = 0.0
-            
-            if len(volumes) >= 10:
-                # تسارع الحجم (الحجم الأخير vs المتوسط)
-                volume_acceleration = (volumes[-1] - np.mean(volumes[-10:])) / np.mean(volumes[-10:])
-                if volume_acceleration > 0.5:  # زيادة حجم بنسبة 50%
-                    volume_momentum_score = 0.2
-                
-                # استمرارية الحجم المرتفع
-                above_avg_volume_count = sum(1 for vol in volumes[-5:] if vol > np.mean(volumes[-20:]))
-                if above_avg_volume_count >= 3:  # 3 من آخر 5 ساعات فوق المتوسط
-                    volume_momentum_score += 0.2
-            
-            # 6. تقييم كفاءة الحركة (Price Efficiency)
-            efficiency_score = 0.0
-            
-            if len(closes) >= 20:
-                # نسبة الشموع الخضراء
-                green_candles = sum(1 for i in range(1, len(closes)) if closes[i] > opens[i])
-                total_candles = len(closes) - 1
-                green_ratio = green_candles / total_candles if total_candles > 0 else 0
-                
-                if 0.4 <= green_ratio <= 0.7:  # توازن صحي
-                    efficiency_score = 0.2
-                
-                # قوة الشموع (متوسط طول الجسم)
-                candle_bodies = [abs(closes[i] - opens[i]) for i in range(len(closes))]
-                avg_body = np.mean(candle_bodies)
-                body_ratio = avg_body / current_price * 100
-                
-                if 0.5 <= body_ratio <= 2:  # شموع ذات أحجام معقولة
-                    efficiency_score += 0.2
-            
-            # الحساب النهائي مع الأوزان
-            weights = {
-                'momentum': 0.30,      # الزخم السعري
-                'liquidity': 0.25,     # السيولة والحجم
-                'trend': 0.20,         # قوة الاتجاه
-                'volatility': 0.10,    # التقلب
-                'volume_momentum': 0.10, # الزخم الحجمي
-                'efficiency': 0.05     # كفاءة الحركة
-            }
-            
-            final_score = (
-                momentum_score * weights['momentum'] +
-                liquidity_score * weights['liquidity'] +
-                trend_score * weights['trend'] +
-                volatility_score * weights['volatility'] +
-                volume_momentum_score * weights['volume_momentum'] +
-                efficiency_score * weights['efficiency']
-            )
-            
-            # معامل تصحيح إضافي للرموز ذات الزخم القوي
-            if momentum_score > 0.6 and volume_ratio > 1.8:
-                final_score = min(final_score * 1.2, 1.0)
-            
-            return min(final_score, 1.0)
-            
-        except Exception as e:
-            print(f"❌ خطأ في حساب الدرجة التقنية لـ {symbol}: {e}")
-            return 0.0
+    def _calculate_volatility(self, high_24h: float, low_24h: float, current_price: float) -> float:
+        """حساب التقلب (بيانات فقط)"""
+        if current_price == 0:
+            return 0.5
+        
+        volatility = (high_24h - low_24h) / current_price
+        
+        if volatility > 0.5:
+            return 0.2
+        elif volatility > 0.2:
+            return 0.4
+        elif volatility > 0.1:
+            return 0.8
+        elif volatility > 0.05:
+            return 0.6
+        else:
+            return 0.3
 
-    async def find_high_potential_candidates(self, count=20):
+    def _generate_layer1_reasons(self, volume_strength: float, price_momentum: float, 
+                               dollar_volume: float, price_change: float) -> List[str]:
+        """توليد أسباب الترشيح بناءً على البيانات فقط"""
+        reasons = []
+        
+        if volume_strength >= 0.6:
+            reasons.append('high_liquidity')
+        elif volume_strength >= 0.4:
+            reasons.append('good_liquidity')
+            
+        if price_change >= 8:
+            reasons.append('strong_positive_momentum')
+        elif price_change >= 3:
+            reasons.append('positive_momentum')
+        elif price_change <= -8:
+            reasons.append('oversold_opportunity')
+        elif price_change <= -3:
+            reasons.append('dip_opportunity')
+            
+        if dollar_volume >= 5000000:
+            reasons.append('very_high_volume')
+        elif dollar_volume >= 2000000:
+            reasons.append('high_volume')
+            
+        return reasons
+
+    async def get_ohlcv_data_for_symbols(self, symbols: List[str]) -> List[Dict[str, Any]]:
         """
-        البحث عن عملات ذات إمكانات عالية بناءً على:
-        - الزخم السعري القوي والمستدام
-        - السيولة الجيدة (أحجام تداول عالية)
-        - اتجاهات تقنية واضحة
-        - مؤشرات حجم داعمة
+        جلب بيانات OHLCV كاملة للرموز المحددة
+        يستخدم في الطبقة 2 للتحليل المتقدم
         """
-        try:
-            print(f"🔍 البحث عن {count} عملة ذات إمكانات عالية بناءً على الزخم والسيولة...")
-            
-            if not self.exchange:
-                print("❌ لا يوجد اتصال بـ KuCoin")
-                return []
-
-            if not self.market_cache or not self.last_market_load or (datetime.now() - self.last_market_load).total_seconds() > 3600:
-                await self._load_markets()
-
-            # الحصول على جميع الرموز النشطة مع USDT
-            usdt_symbols = [
-                symbol for symbol in self.market_cache.keys() 
-                if symbol.endswith('/USDT') and self.market_cache[symbol].get('active', False)
-            ]
-            
-            print(f"✅ تم العثور على {len(usdt_symbols)} رمز USDT نشط في KuCoin")
-            
-            # المرحلة 1: الفحص السريع بناءً على بيانات Ticker
-            print("📊 المرحلة 1: الفحص السريع بناءً على أحجام التداول والزخم...")
-            initial_candidates = []
-            
-            for i, symbol in enumerate(usdt_symbols):
-                try:
-                    # الحصول على بيانات التداول الأساسية
-                    ticker = await self.exchange.fetch_ticker(symbol)
-                    if not ticker:
-                        continue
-                    
-                    volume_24h = ticker.get('baseVolume', 0)
-                    price_change_24h = ticker.get('percentage', 0)
-                    current_price = ticker.get('last', 0)
-                    
-                    # معايير الفحص الأولي:
-                    # - حجم تداول > 100,000 دولار
-                    # - تغير سعري > 1% (إيجابي أو سلبي)
-                    # - سعر بين 0.001 و 500 دولار (تجنب العملات منخفضة/مرتفعة السعر جداً)
-                    if (volume_24h * current_price > 100000 and  # حجم بالدولار
-                        abs(price_change_24h) > 1.0 and          # زخم سعري
-                        0.001 <= current_price <= 500):          # نطاق سعري معقول
-                        
-                        reasons = []
-                        if price_change_24h > 5:
-                            reasons.append('strong_positive_momentum')
-                        elif price_change_24h > 2:
-                            reasons.append('positive_momentum')
-                        
-                        if volume_24h * current_price > 1000000:
-                            reasons.append('high_liquidity')
-                        elif volume_24h * current_price > 500000:
-                            reasons.append('good_liquidity')
-                        
-                        initial_candidates.append({
-                            'symbol': symbol,
-                            'volume_24h': volume_24h,
-                            'dollar_volume': volume_24h * current_price,
-                            'price_change_24h': price_change_24h,
-                            'current_price': current_price,
-                            'reasons': reasons
-                        })
-                    
-                    # عرض التقدم كل 100 رمز
-                    if i % 100 == 0 and i > 0:
-                        print(f"   🔍 تم فحص {i} رمز، وجدنا {len(initial_candidates)} مرشح أولي")
-                        
-                except Exception as e:
-                    if "rate limit" not in str(e).lower():
-                        continue
-            
-            print(f"✅ انتهت المرحلة 1: تم اختيار {len(initial_candidates)} مرشح أولي")
-            
-            # إذا لم نجد مرشحين كافيين، نخفف المعايير
-            if len(initial_candidates) < count * 2:
-                print("⚠️ عدد المرشحين قليل، نخفف معايير الفحص...")
-                for symbol in usdt_symbols:
-                    if len(initial_candidates) >= count * 3:
-                        break
-                    
-                    if symbol in [c['symbol'] for c in initial_candidates]:
-                        continue
-                    
+        results = []
+        
+        print(f"📊 جلب بيانات OHLCV لـ {len(symbols)} عملة...")
+        
+        for symbol in symbols:
+            try:
+                ohlcv_data = {}
+                timeframes = [
+                    ('5m', 100), ('15m', 100), ('1h', 100), 
+                    ('4h', 100), ('1d', 100), ('1w', 50)
+                ]
+                
+                has_sufficient_data = True
+                for timeframe, limit in timeframes:
                     try:
-                        ticker = await self.exchange.fetch_ticker(symbol)
-                        if not ticker:
-                            continue
-                        
-                        volume_24h = ticker.get('baseVolume', 0)
-                        price_change_24h = ticker.get('percentage', 0)
-                        current_price = ticker.get('last', 0)
-                        
-                        # معايير مخففة
-                        if (volume_24h * current_price > 50000 and  # حجم بالدولار
-                            abs(price_change_24h) > 0.5 and         # زخم سعري
-                            0.0005 <= current_price <= 1000):       # نطاق سعري أوسع
-                            
-                            reasons = ['relaxed_criteria']
-                            if price_change_24h > 0:
-                                reasons.append('positive_trend')
-                            
-                            initial_candidates.append({
-                                'symbol': symbol,
-                                'volume_24h': volume_24h,
-                                'dollar_volume': volume_24h * current_price,
-                                'price_change_24h': price_change_24h,
-                                'current_price': current_price,
-                                'reasons': reasons
-                            })
-                            
-                    except Exception:
-                        continue
-            
-            print(f"📊 بعد التخفيف: {len(initial_candidates)} مرشح")
-            
-            # المرحلة 2: التحليل التقني المتعمق
-            print("📈 المرحلة 2: التحليل التقني المتعمق للمرشحين...")
-            candidates_with_scores = []
-            analyzed_count = 0
-            
-            # نرتب المرشحين بحجم التداول (الأكبر أولاً)
-            initial_candidates.sort(key=lambda x: x['dollar_volume'], reverse=True)
-            
-            for candidate in initial_candidates[:100]:  # نأخذ أفضل 100 من حيث الحجم
-                try:
-                    symbol = candidate['symbol']
-                    analyzed_count += 1
-                    
-                    if analyzed_count % 10 == 0:
-                        print(f"   🔍 تحليل تقني {analyzed_count} من {min(100, len(initial_candidates))}")
-                    
-                    # جلب بيانات OHLCV للتحليل التقني
-                    ohlcv_1h = await self.exchange.fetch_ohlcv(symbol, '1h', limit=100)
-                    
-                    if not ohlcv_1h or len(ohlcv_1h) < 50:
-                        continue
-                    
-                    ohlcv_data = {'1h': ohlcv_1h}
-                    
-                    # حساب الدرجة التقنية الشاملة
-                    technical_score = await self._calculate_technical_score(symbol, ohlcv_data)
-                    
-                    if technical_score > 0.3:  # عتبة مقبولة للجودة
-                        # تحديث أسباب الترشيح بناءً على التحليل التقني
-                        reasons = candidate['reasons']
-                        
-                        if technical_score > 0.7:
-                            reasons.append('excellent_technical_score')
-                        elif technical_score > 0.5:
-                            reasons.append('good_technical_score')
-                        
-                        # إضافة أسباب تقنية
-                        if candidate['price_change_24h'] > 8:
-                            reasons.append('strong_daily_momentum')
-                        elif candidate['price_change_24h'] > 3:
-                            reasons.append('moderate_daily_momentum')
-                        
-                        if candidate['dollar_volume'] > 2000000:
-                            reasons.append('very_high_liquidity')
-                        elif candidate['dollar_volume'] > 500000:
-                            reasons.append('high_liquidity')
-                        
-                        candidates_with_scores.append({
-                            'symbol': symbol,
-                            'technical_score': technical_score,
-                            'reasons': reasons,
-                            'volume': candidate['volume_24h'],
-                            'dollar_volume': candidate['dollar_volume'],
-                            'price_change': candidate['price_change_24h'],
-                            'current_price': candidate['current_price'],
-                            'market_cap_category': self._classify_market_cap(candidate['dollar_volume'])
-                        })
-                    
-                except Exception as e:
-                    if "rate limit" not in str(e).lower():
-                        print(f"⚠️ خطأ في التحليل التقني للرمز {symbol}: {e}")
-                    continue
-            
-            print(f"✅ انتهت المرحلة 2: {len(candidates_with_scores)} مرشح اجتازوا التحليل التقني")
-            
-            # المرحلة 3: الاختيار النهائي مع التنوع
-            if not candidates_with_scores:
-                print("❌ لم يتم العثور على أي مرشح يلبي المعايير")
-                return []
-            
-            # ترتيب المرشحين حسب الدرجة التقنية
-            candidates_with_scores.sort(key=lambda x: x['technical_score'], reverse=True)
-            
-            # نأخذ أفضل المرشحين مع الحفاظ على التنوع
-            final_candidates = []
-            categories_count = {'LARGE': 0, 'MID': 0, 'SMALL': 0}
-            max_per_category = max(1, count // 3)
-            
-            for candidate in candidates_with_scores:
-                category = candidate['market_cap_category']
-                
-                if categories_count[category] < max_per_category:
-                    final_candidates.append(candidate)
-                    categories_count[category] += 1
-                elif len(final_candidates) < count:
-                    final_candidates.append(candidate)
-                
-                if len(final_candidates) >= count:
-                    break
-            
-            print(f"🎯 الاختيار النهائي: {len(final_candidates)} مرشح متنوع")
-            print(f"   📊 تصنيف الأحجام: Large({categories_count['LARGE']}), Mid({categories_count['MID']}), Small({categories_count['SMALL']})")
-            
-            # عرض أفضل 5 مرشحين
-            for i, candidate in enumerate(final_candidates[:5]):
-                print(f"   🥇 {i+1}. {candidate['symbol']}: درجة {candidate['technical_score']:.3f} - تغير {candidate['price_change']:.1f}% - حجم ${candidate['dollar_volume']:,.0f}")
-            
-            return final_candidates
-            
-        except Exception as e:
-            print(f"❌ خطأ في find_high_potential_candidates: {e}")
-            import traceback
-            traceback.print_exc()
-            return []
-
-    def _classify_market_cap(self, dollar_volume):
-        """تصنيف العملات حسب حجم التداول"""
-        if dollar_volume > 5000000:    # أكثر من 5 ملايين دولار
-            return "LARGE"
-        elif dollar_volume > 1000000:  # أكثر من 1 مليون دولار
-            return "MID"
-        else:                          # أقل من 1 مليون دولار
-            return "SMALL"
-
-    async def get_fast_pass_data_async(self, candidates):
-        try:
-            print(f"📊 جلب بيانات OHLCV لـ {len(candidates)} مرشح من KuCoin...")
-            results = []
-            
-            timeframes = [
-                ('5m', 200),
-                ('15m', 200), 
-                ('1h', 200),
-                ('4h', 200),
-                ('1d', 200),
-                ('1w', 200)
-            ]
-            
-            for candidate in candidates:
-                symbol = candidate['symbol']
-                
-                try:
-                    ohlcv_data = {}
-                    has_sufficient_data = True
-                    
-                    for timeframe, limit in timeframes:
-                        try:
-                            ohlcv = await self.exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
-                            
-                            if not ohlcv or len(ohlcv) < 50:
-                                print(f"⚠️ بيانات غير كافية للرمز {symbol} في الإطار {timeframe}: {len(ohlcv) if ohlcv else 0} شمعة")
-                                has_sufficient_data = False
-                                break
-                                
+                        ohlcv = await self.exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
+                        if ohlcv and len(ohlcv) >= 20:
                             ohlcv_data[timeframe] = ohlcv
-                            print(f"   ✅ {symbol} - {timeframe}: {len(ohlcv)} شمعة")
-                            
-                            await asyncio.sleep(0.1)
-                            
-                        except Exception as e:
-                            print(f"❌ خطأ في جلب بيانات {symbol} للإطار {timeframe}: {e}")
+                        else:
                             has_sufficient_data = False
                             break
+                    except Exception:
+                        has_sufficient_data = False
+                        break
+                
+                if has_sufficient_data:
+                    # الحصول على بيانات التداول الحالية
+                    ticker = await self.exchange.fetch_ticker(symbol)
+                    current_price = ticker.get('last', 0) if ticker else 0
                     
-                    if has_sufficient_data:
-                        result_data = {
-                            'symbol': symbol,
-                            'ohlcv': ohlcv_data,
-                            'reasons': candidate.get('reasons', []),
-                            'technical_score': candidate.get('technical_score', 0)
-                        }
-                        
-                        results.append(result_data)
-                        print(f"✅ تم تجميع بيانات {symbol} بنجاح")
-                    else:
-                        print(f"❌ فشل تجميع بيانات كافية لـ {symbol}")
-                    
-                except Exception as symbol_error:
-                    print(f"❌ خطأ في معالجة الرمز {symbol}: {symbol_error}")
-                    continue
-            
-            print(f"✅ تم تجميع بيانات لـ {len(results)} مرشح بنجاح")
-            return results
-            
-        except Exception as e:
-            print(f"❌ خطأ في get_fast_pass_data_async: {e}")
-            return []
+                    result_data = {
+                        'symbol': symbol,
+                        'ohlcv': ohlcv_data,
+                        'current_price': current_price,
+                        'timestamp': datetime.now().isoformat()
+                    }
+                    results.append(result_data)
+                
+                await asyncio.sleep(0.1)
+                
+            except Exception as symbol_error:
+                print(f"❌ خطأ في جلب بيانات {symbol}: {symbol_error}")
+                continue
+        
+        print(f"✅ تم تجميع بيانات OHLCV لـ {len(results)} عملة")
+        return results
 
     async def get_latest_price_async(self, symbol):
+        """جلب السعر الحالي لعملة محددة"""
         try:
             if not self.exchange:
-                print("❌ لا يوجد اتصال بـ KuCoin")
-                return None
-
-            if symbol not in self.market_cache:
-                print(f"⚠️ السوق {symbol} غير متوفر في KuCoin")
                 return None
 
             ticker = await self.exchange.fetch_ticker(symbol)
@@ -990,14 +472,14 @@ class DataManager:
             if current_price:
                 return float(current_price)
             else:
-                print(f"❌ لم يتم العثور على سعر لـ {symbol}")
                 return None
             
         except Exception as e:
-            print(f"❌ خطأ في get_latest_price_async لـ {symbol}: {e}")
+            print(f"❌ خطأ في جلب السعر لـ {symbol}: {e}")
             return None
 
     async def get_available_symbols(self):
+        """الحصول على جميع الرموز المتاحة"""
         try:
             if not self.exchange:
                 return []
@@ -1013,10 +495,11 @@ class DataManager:
             return usdt_symbols
             
         except Exception as e:
-            print(f"❌ خطأ في get_available_symbols: {e}")
+            print(f"❌ خطأ في جلب الرموز المتاحة: {e}")
             return []
 
     async def validate_symbol(self, symbol):
+        """التحقق من صحة الرمز"""
         try:
             if not self.exchange:
                 return False
@@ -1027,7 +510,7 @@ class DataManager:
             return symbol in self.market_cache and self.market_cache[symbol].get('active', False)
             
         except Exception as e:
-            print(f"❌ خطأ في validate_symbol لـ {symbol}: {e}")
+            print(f"❌ خطأ في التحقق من الرمز {symbol}: {e}")
             return False
 
-print("✅ DataManager loaded - Real-time market data from KuCoin ready (General Whale Monitoring DISABLED)")
+print("✅ DataManager loaded - Focused on data retrieval only")