Update data_manager.py

data_manager.py

@@ -9,6 +9,7 @@ import ccxt.pro as ccxt
 import numpy as np
 import logging
 from typing import List, Dict, Any
+from concurrent.futures import ThreadPoolExecutor
 
 logging.getLogger("httpx").setLevel(logging.WARNING)
 logging.getLogger("httpcore").setLevel(logging.WARNING)
@@ -18,14 +19,19 @@ class DataManager:
         self.contracts_db = contracts_db or {}
         self.whale_monitor = whale_monitor
         
+        # إعدادات الأداء المحسنة
+        self.batch_size = 100  # زيادة حجم الدفعة
+        self.max_workers = 20  # زيادة العاملين المتوازيين
+        self.cache_duration = 300  # تخزين النتائج لمدة 5 دقائق
+        
         try:
             self.exchange = ccxt.kucoin({
                 'sandbox': False,
                 'enableRateLimit': True,
-                'timeout': 30000,
+                'timeout': 15000,  # تقليل المهلة
                 'verbose': False
             })
-            self.exchange.rateLimit = 800
+            self.exchange.rateLimit = 500  # زيادة معدل الطلبات
             print("✅ تم تهيئة اتصال KuCoin بنجاح")
         except Exception as e:
             print(f"❌ فشل تهيئة اتصال KuCoin: {e}")
@@ -34,11 +40,13 @@ class DataManager:
         self.http_client = None
         self.market_cache = {}
         self.last_market_load = None
+        self.symbol_cache = {}
+        self.cache_timestamp = {}
         
     async def initialize(self):
-        self.http_client = httpx.AsyncClient(timeout=20.0)
+        self.http_client = httpx.AsyncClient(timeout=10.0)  # تقليل المهلة
         await self._load_markets()
-        print("✅ DataManager initialized - Focused on data retrieval only")
+        print("✅ DataManager initialized - Optimized for performance")
 
     async def _load_markets(self):
         try:
@@ -63,8 +71,11 @@ class DataManager:
     async def get_market_context_async(self):
         """جلب سياق السوق الأساسي فقط"""
         try:
-            sentiment_data = await self.get_sentiment_safe_async()
-            price_data = await self._get_prices_with_fallback()
+            # استخدام المهام المتوازية
+            sentiment_task = asyncio.create_task(self.get_sentiment_safe_async())
+            price_task = asyncio.create_task(self._get_prices_with_fallback())
+            
+            sentiment_data, price_data = await asyncio.gather(sentiment_task, price_task)
             
             bitcoin_price = price_data.get('bitcoin')
             ethereum_price = price_data.get('ethereum')
@@ -89,7 +100,7 @@ class DataManager:
     async def get_sentiment_safe_async(self):
         """جلب بيانات المشاعر"""
         try:
-            async with httpx.AsyncClient(timeout=8) as client:
+            async with httpx.AsyncClient(timeout=5) as client:  # تقليل المهلة
                 response = await client.get("https://api.alternative.me/fng/")
                 response.raise_for_status()
                 data = response.json()
@@ -109,26 +120,14 @@ class DataManager:
             return None
 
     def _determine_market_trend(self, bitcoin_price, sentiment_data):
-        """تحديد اتجاه السوق"""
+        """تحديد اتجاه السوق (مبسط)"""
         if bitcoin_price is None:
             return "UNKNOWN"
         
-        score = 0
+        # حساب مبسط وسريع
         if bitcoin_price > 60000: 
-            score += 1
-        elif bitcoin_price < 55000: 
-            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 score >= 1: 
             return "bull_market"
-        elif score <= -1: 
+        elif bitcoin_price < 55000: 
             return "bear_market"
         else:
             return "sideways_market"
@@ -146,10 +145,31 @@ class DataManager:
     async def _get_prices_with_fallback(self):
         """جلب أسعار البيتكوين والإيثيريوم"""
         try:
+            # محاولة KuCoin أولاً
             prices = await self._get_prices_from_kucoin_safe()
             if prices.get('bitcoin') and prices.get('ethereum'):
                 return prices
-            return await self._get_prices_from_coingecko()
+            
+            # استخدام المهام المتوازية للبدائل
+            coingecko_task = asyncio.create_task(self._get_prices_from_coingecko())
+            binance_task = asyncio.create_task(self._get_prices_from_binance())
+            
+            done, pending = await asyncio.wait(
+                [coingecko_task, binance_task],
+                timeout=3,
+                return_when=asyncio.FIRST_COMPLETED
+            )
+            
+            for task in done:
+                result = task.result()
+                if result.get('bitcoin') and result.get('ethereum'):
+                    # إلغاء المهام المعلقة
+                    for pending_task in pending:
+                        pending_task.cancel()
+                    return result
+            
+            return {'bitcoin': None, 'ethereum': None}
+            
         except Exception as e:
             print(f"❌ فشل جلب الأسعار: {e}")
             return {'bitcoin': None, 'ethereum': None}
@@ -159,17 +179,19 @@ class DataManager:
             return {'bitcoin': None, 'ethereum': None}
             
         try:
+            # استخدام المهام المتوازية لجلب الأسعار
+            btc_task = asyncio.create_task(self.exchange.fetch_ticker('BTC/USDT'))
+            eth_task = asyncio.create_task(self.exchange.fetch_ticker('ETH/USDT'))
+            
+            btc_ticker, eth_ticker = await asyncio.gather(btc_task, eth_task, return_exceptions=True)
+            
             prices = {'bitcoin': None, 'ethereum': None}
             
-            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
+            if not isinstance(btc_ticker, Exception) and btc_ticker.get('last'):
+                prices['bitcoin'] = float(btc_ticker.get('last', 0))
             
-            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
+            if not isinstance(eth_ticker, Exception) and eth_ticker.get('last'):
+                prices['ethereum'] = float(eth_ticker.get('last', 0))
             
             return prices
             
@@ -180,10 +202,9 @@ class DataManager:
     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"
             async with httpx.AsyncClient() as client:
-                response = await client.get(url, timeout=10)
+                response = await client.get(url, timeout=5)
                 response.raise_for_status()
                 data = response.json()
                 
@@ -199,6 +220,30 @@ class DataManager:
             print(f"❌ فشل جلب الأسعار من CoinGecko: {e}")
             return {'bitcoin': None, 'ethereum': None}
 
+    async def _get_prices_from_binance(self):
+        """الاحتياطي: جلب الأسعار من Binance"""
+        try:
+            url = "https://api.binance.com/api/v3/ticker/price"
+            async with httpx.AsyncClient() as client:
+                response = await client.get(url, timeout=5)
+                response.raise_for_status()
+                data = response.json()
+                
+                btc_price = None
+                eth_price = None
+                
+                for ticker in data:
+                    if ticker['symbol'] == 'BTCUSDT':
+                        btc_price = float(ticker['price'])
+                    elif ticker['symbol'] == 'ETHUSDT':
+                        eth_price = float(ticker['price'])
+                
+                return {'bitcoin': btc_price, 'ethereum': eth_price}
+                    
+        except Exception as e:
+            print(f"❌ فشل جلب الأسعار من Binance: {e}")
+            return {'bitcoin': None, 'ethereum': None}
+
     def _get_minimal_market_context(self):
         """سياق سوق بدائي عند الفشل"""
         return {
@@ -211,8 +256,7 @@ class DataManager:
 
     async def layer1_rapid_screening(self) -> List[Dict[str, Any]]:
         """
-        الطبقة 1: فحص سريع لجميع عملات KuCoin
-        يركز فقط على جلب البيانات الأساسية بدون تحليل متقدم
+        الطبقة 1: فحص سريع محسن لجميع عملات KuCoin
         """
         candidates = []
         
@@ -222,17 +266,19 @@ class DataManager:
             if symbol.endswith('/USDT') and self.market_cache[symbol].get('active', False)
         ]
         
-        print(f"📊 الطبقة 1: فحص سريع لـ {len(usdt_symbols)} عملة في KuCoin...")
+        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}...")
+        # استخدام دفعات أكبر ومعالجة متوازية
+        for i in range(0, len(usdt_symbols), self.batch_size):
+            batch = usdt_symbols[i:i + self.batch_size]
+            print(f"   🔍 معالجة مجموعة {i//self.batch_size + 1}/{(len(usdt_symbols)//self.batch_size)+1}...")
             
-            batch_candidates = await self._process_batch_rapid_screening(batch)
+            batch_candidates = await self._process_batch_rapid_screening_optimized(batch)
             candidates.extend(batch_candidates)
             
-            await asyncio.sleep(1)
+            # تقليل وقت الانتظار بين الدفعات
+            if i + self.batch_size < len(usdt_symbols):
+                await asyncio.sleep(0.1)  # تقليل وقت الانتظار
         
         # ترتيب المرشحين حسب قوة الأساسيات
         candidates.sort(key=lambda x: x.get('layer1_score', 0), reverse=True)
@@ -253,143 +299,152 @@ class DataManager:
         
         return final_candidates
 
-    async def _process_batch_rapid_screening(self, symbols_batch: List[str]) -> List[Dict[str, Any]]:
-        """معالجة دفعة من الرموز في الطبقة 1"""
+    async def _process_batch_rapid_screening_optimized(self, symbols_batch: List[str]) -> List[Dict[str, Any]]:
+        """معالجة دفعة من الرموز في الطبقة 1 بشكل متوازي ومحسن"""
         candidates = []
         
+        # استخدام asyncio.gather للمعالجة المتوازية
+        tasks = []
         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
+            # التحقق من التخزين المؤقت أولاً
+            cache_key = f"ticker_{symbol}"
+            if (cache_key in self.symbol_cache and 
+                time.time() - self.cache_timestamp.get(cache_key, 0) < self.cache_duration):
+                tasks.append(asyncio.create_task(self._process_cached_symbol(symbol)))
+            else:
+                tasks.append(asyncio.create_task(self._process_symbol_optimized(symbol)))
+        
+        # انتظار اكتمال جميع المهام
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        for result in results:
+            if isinstance(result, Exception) or result is None:
+                continue
+            candidates.append(result)
         
         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
+    async def _process_cached_symbol(self, symbol: str):
+        """معالجة الرمز من التخزين المؤقت"""
+        cache_key = f"ticker_{symbol}"
+        cached_data = self.symbol_cache.get(cache_key)
+        if cached_data and self._validate_cached_data(cached_data):
+            return cached_data
         else:
-            return 0.2
+            # إذا كانت البيانات المخزنة غير صالحة، معالجة جديدة
+            return await self._process_symbol_optimized(symbol)
 
-    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 _process_symbol_optimized(self, symbol: str):
+        """معالجة رمز واحد بشكل محسن"""
+        try:
+            # جلب بيانات التداول الأساسية فقط
+            ticker = await asyncio.wait_for(
+                self.exchange.fetch_ticker(symbol),
+                timeout=5  # مهلة مخفضة
+            )
+            
+            if not ticker:
+                return None
+            
+            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)
+            
+            # فحص سريع للمعايير الأساسية
+            if not self._quick_validation(current_price, dollar_volume, high_24h, low_24h):
+                return None
+            
+            # حساب مؤشرات أساسية سريعة
+            layer1_score = self._calculate_fast_layer1_score(
+                dollar_volume, price_change_24h, current_price, high_24h, low_24h
+            )
+            
+            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,
+                    'reasons': self._generate_fast_reasons(dollar_volume, price_change_24h)
+                }
+                
+                # تخزين في الذاكرة المؤقتة
+                cache_key = f"ticker_{symbol}"
+                self.symbol_cache[cache_key] = candidate_data
+                self.cache_timestamp[cache_key] = time.time()
+                
+                return candidate_data
+            else:
+                return None
+                
+        except (asyncio.TimeoutError, Exception) as e:
+            if "rate limit" not in str(e).lower():
+                continue
+            return None
 
-    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 0.5
+    def _quick_validation(self, current_price, dollar_volume, high_24h, low_24h):
+        """تحقق سريع من المعايير الأساسية"""
+        return all([
+            dollar_volume >= 1000000,      # حجم تداول لا يقل عن 1M دولار
+            current_price > 0.00000001,   # أي سعر مقبول
+            current_price <= 100000,      # حد أقصى معقول
+            high_24h > 0,                 # بيانات سعر صالحة
+            low_24h > 0,
+            high_24h != low_24h           # تجنب الأسعار الثابتة
+        ])
 
-    def _calculate_volatility(self, high_24h: float, low_24h: float, current_price: float) -> float:
-        """حساب التقلب (بيانات فقط)"""
-        if current_price == 0:
-            return 0.5
+    def _calculate_fast_layer1_score(self, dollar_volume, price_change, current_price, high_24h, low_24h):
+        """حساب سريع لدرجة الطبقة 1"""
+        # حساب مبسط للحجم (بدون تعقيد)
+        volume_score = min(dollar_volume / 5000000, 1.0)  # تطبيع إلى 5M
         
-        volatility = (high_24h - low_24h) / current_price
+        # حساب مبكر للزخم
+        if price_change >= 15:
+            momentum_score = 0.9
+        elif price_change >= 8:
+            momentum_score = 0.7
+        elif price_change >= 3:
+            momentum_score = 0.5
+        elif price_change <= -15:
+            momentum_score = 0.8  # فرصة شراء في الانخفاض
+        elif price_change <= -8:
+            momentum_score = 0.6
+        elif price_change <= -3:
+            momentum_score = 0.4
+        else:
+            momentum_score = 0.3
         
-        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
+        # حساب موقع السعر بشكل مبسط
+        if high_24h != low_24h:
+            position = (current_price - low_24h) / (high_24h - low_24h)
+            if position < 0.3:
+                position_score = 0.8
+            elif position > 0.7:
+                position_score = 0.6
+            else:
+                position_score = 0.5
         else:
-            return 0.3
+            position_score = 0.5
+        
+        # الدرجة النهائية المبسطة
+        return (volume_score * 0.4 + momentum_score * 0.4 + position_score * 0.2)
 
-    def _generate_layer1_reasons(self, volume_strength: float, price_momentum: float, 
-                               dollar_volume: float, price_change: float) -> List[str]:
-        """توليد أسباب الترشيح بناءً على البيانات فقط"""
+    def _generate_fast_reasons(self, dollar_volume, price_change):
+        """توليد أسباب سريعة"""
         reasons = []
         
-        if volume_strength >= 0.6:
-            reasons.append('high_liquidity')
-        elif volume_strength >= 0.4:
+        if dollar_volume >= 5000000:
+            reasons.append('very_high_volume')
+        elif dollar_volume >= 2000000:
+            reasons.append('high_volume')
+        else:
             reasons.append('good_liquidity')
             
         if price_change >= 8:
@@ -401,81 +456,125 @@ class DataManager:
         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
 
+    def _validate_cached_data(self, cached_data):
+        """التحقق من صحة البيانات المخزنة"""
+        if not cached_data:
+            return False
+        
+        # التحقق من عمر البيانات
+        cache_key = f"ticker_{cached_data['symbol']}"
+        cache_time = self.cache_timestamp.get(cache_key, 0)
+        if time.time() - cache_time > self.cache_duration:
+            return False
+        
+        # التحقق من صحة البيانات
+        required_fields = ['symbol', 'current_price', 'dollar_volume', 'layer1_score']
+        return all(field in cached_data for field in required_fields)
+
     async def get_ohlcv_data_for_symbols(self, symbols: List[str]) -> List[Dict[str, Any]]:
         """
-        جلب بيانات OHLCV كاملة للرموز المحددة
-        يستخدم في الطبقة 2 للتحليل المتقدم
+        جلب بيانات OHLCV كاملة للرموز المحددة بشكل متواز
         """
         results = []
         
         print(f"📊 جلب بيانات OHLCV لـ {len(symbols)} عملة...")
         
+        # استخدام المهام المتوازية لجلب البيانات
+        tasks = []
         for symbol in symbols:
+            task = asyncio.create_task(self._fetch_ohlcv_for_symbol(symbol))
+            tasks.append(task)
+        
+        # معالجة النتائج مع تحديد مهلة
+        for task in asyncio.as_completed(tasks, timeout=30):
             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:
-                        ohlcv = await self.exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
-                        if ohlcv and len(ohlcv) >= 20:
-                            ohlcv_data[timeframe] = ohlcv
-                        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
-                    
-                    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}")
+                result = await task
+                if result:
+                    results.append(result)
+            except (asyncio.TimeoutError, Exception) as e:
                 continue
         
         print(f"✅ تم تجميع بيانات OHLCV لـ {len(results)} عملة")
         return results
 
+    async def _fetch_ohlcv_for_symbol(self, symbol: str):
+        """جلب بيانات OHLCV لرمز واحد"""
+        try:
+            ohlcv_data = {}
+            timeframes = [
+                ('5m', 50),  # تقليل عدد الشموع
+                ('15m', 50), 
+                ('1h', 50), 
+                ('4h', 50), 
+                ('1d', 30),  # تقليل للبيانات اليومية
+            ]
+            
+            has_sufficient_data = True
+            for timeframe, limit in timeframes:
+                try:
+                    ohlcv = await asyncio.wait_for(
+                        self.exchange.fetch_ohlcv(symbol, timeframe, limit=limit),
+                        timeout=5
+                    )
+                    if ohlcv and len(ohlcv) >= 15:  # تقليل الحد الأدنى
+                        ohlcv_data[timeframe] = ohlcv
+                    else:
+                        has_sufficient_data = False
+                        break
+                except (asyncio.TimeoutError, Exception):
+                    has_sufficient_data = False
+                    break
+            
+            if has_sufficient_data:
+                # جلب السعر الحالي بشكل منفصل
+                ticker = await asyncio.wait_for(
+                    self.exchange.fetch_ticker(symbol),
+                    timeout=3
+                )
+                current_price = ticker.get('last', 0) if ticker else 0
+                
+                return {
+                    'symbol': symbol,
+                    'ohlcv': ohlcv_data,
+                    'current_price': current_price,
+                    'timestamp': datetime.now().isoformat()
+                }
+            else:
+                return None
+                
+        except Exception as symbol_error:
+            return None
+
     async def get_latest_price_async(self, symbol):
         """جلب السعر الحالي لعملة محددة"""
         try:
             if not self.exchange:
                 return None
 
-            ticker = await self.exchange.fetch_ticker(symbol)
+            # التحقق من التخزين المؤقت أولاً
+            cache_key = f"price_{symbol}"
+            if (cache_key in self.symbol_cache and 
+                time.time() - self.cache_timestamp.get(cache_key, 0) < 10):  # تخزين الأسعار لمدة 10 ثوان
+                return self.symbol_cache[cache_key].get('current_price')
+
+            ticker = await asyncio.wait_for(
+                self.exchange.fetch_ticker(symbol),
+                timeout=3
+            )
             current_price = ticker.get('last')
             
             if current_price:
-                return float(current_price)
+                price = float(current_price)
+                # تحديث التخزين المؤقت
+                self.symbol_cache[cache_key] = {'current_price': price}
+                self.cache_timestamp[cache_key] = time.time()
+                return price
             else:
                 return None
             
         except Exception as e:
-            print(f"❌ خطأ في جلب السعر لـ {symbol}: {e}")
             return None
 
     async def get_available_symbols(self):
@@ -513,4 +612,10 @@ class DataManager:
             print(f"❌ خطأ في التحقق من الرمز {symbol}: {e}")
             return False
 
-print("✅ DataManager loaded - Focused on data retrieval only")
+    def clear_cache(self):
+        """مسح الذاكرة المؤقتة"""
+        self.symbol_cache.clear()
+        self.cache_timestamp.clear()
+        print("✅ تم مسح الذاكرة المؤقتة")
+
+print("✅ DataManager loaded - Optimized for high performance screening")