Update data_manager.py

data_manager.py

@@ -9,7 +9,6 @@ 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)
@@ -20,18 +19,17 @@ class DataManager:
         self.whale_monitor = whale_monitor
         
         # إعدادات الأداء المحسنة
-        self.batch_size = 100  # زيادة حجم الدفعة
-        self.max_workers = 20  # زيادة العاملين المتوازيين
-        self.cache_duration = 300  # تخزين النتائج لمدة 5 دقائق
+        self.batch_size = 50  # تخفيض حجم الدفعة لتجنب rate limits
+        self.cache_duration = 300
         
         try:
             self.exchange = ccxt.kucoin({
                 'sandbox': False,
                 'enableRateLimit': True,
-                'timeout': 15000,  # تقليل المهلة
-                'verbose': False
+                'timeout': 30000,  # زيادة المهلة
+                'verbose': False,
+                'rateLimit': 1000,  # زيادة معدل الطلبات
             })
-            self.exchange.rateLimit = 500  # زيادة معدل الطلبات
             print("✅ تم تهيئة اتصال KuCoin بنجاح")
         except Exception as e:
             print(f"❌ فشل تهيئة اتصال KuCoin: {e}")
@@ -44,9 +42,9 @@ class DataManager:
         self.cache_timestamp = {}
         
     async def initialize(self):
-        self.http_client = httpx.AsyncClient(timeout=10.0)  # تقليل المهلة
+        self.http_client = httpx.AsyncClient(timeout=30.0)
         await self._load_markets()
-        print("✅ DataManager initialized - Optimized for performance")
+        print("✅ DataManager initialized - Optimized for OHLCV data retrieval")
 
     async def _load_markets(self):
         try:
@@ -71,11 +69,8 @@ class DataManager:
     async def get_market_context_async(self):
         """جلب سياق السوق الأساسي فقط"""
         try:
-            # استخدام المهام المتوازية
-            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)
+            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')
@@ -100,7 +95,7 @@ class DataManager:
     async def get_sentiment_safe_async(self):
         """جلب بيانات المشاعر"""
         try:
-            async with httpx.AsyncClient(timeout=5) as client:  # تقليل المهلة
+            async with httpx.AsyncClient(timeout=10) as client:
                 response = await client.get("https://api.alternative.me/fng/")
                 response.raise_for_status()
                 data = response.json()
@@ -120,14 +115,26 @@ 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: 
-            return "bull_market"
+            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: 
             return "bear_market"
         else:
             return "sideways_market"
@@ -145,31 +152,10 @@ 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
-            
-            # استخدام المهام المتوازية للبدائل
-            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}
-            
+            return await self._get_prices_from_coingecko()
         except Exception as e:
             print(f"❌ فشل جلب الأسعار: {e}")
             return {'bitcoin': None, 'ethereum': None}
@@ -179,19 +165,17 @@ 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}
             
-            if not isinstance(btc_ticker, Exception) and btc_ticker.get('last'):
-                prices['bitcoin'] = float(btc_ticker.get('last', 0))
+            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(eth_ticker, Exception) and eth_ticker.get('last'):
-                prices['ethereum'] = float(eth_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
             
             return prices
             
@@ -202,9 +186,10 @@ 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=5)
+                response = await client.get(url, timeout=10)
                 response.raise_for_status()
                 data = response.json()
                 
@@ -220,30 +205,6 @@ 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 {
@@ -256,7 +217,8 @@ class DataManager:
 
     async def layer1_rapid_screening(self) -> List[Dict[str, Any]]:
         """
-        الطبقة 1: فحص سريع محسن لجميع عملات KuCoin
+        الطبقة 1: فحص سريع لجميع عملات KuCoin
+        يركز فقط على جلب البيانات الأساسية بدون تحليل متقدم
         """
         candidates = []
         
@@ -266,39 +228,26 @@ 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...")
         
-        # استخدام دفعات أكبر ومعالجة متوازية
-        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_size = 20  # تخفيض حجم الدفعة لتجنب rate limits
+        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}...")
             
-            batch_candidates = await self._process_batch_rapid_screening_optimized(batch)
+            batch_candidates = await self._process_batch_rapid_screening(batch)
             candidates.extend(batch_candidates)
             
-            # تقليل وقت الانتظار بين الدفعات
-            if i + self.batch_size < len(usdt_symbols):
-                await asyncio.sleep(0.1)  # تقليل وقت الانتظار
-        
-        print(f"📊 تم جمع {len(candidates)} مرشح مؤهل من الطبقة 1")
-        
-        if not candidates:
-            print("❌ لم يتم العثور على أي مرشح مؤهل")
-            return []
+            await asyncio.sleep(1)  # زيادة وقت الانتظار بين الدفعات
         
         # ترتيب المرشحين حسب قوة الأساسيات
         candidates.sort(key=lambda x: x.get('layer1_score', 0), reverse=True)
         
-        # إصلاح الخطأ: تحديد عدد المرشحين بشكل صحيح
-        target_count = min(max(80, len(candidates) // 2), 180, len(candidates))
-        
-        # إذا كان لدينا عدد قليل من المرشحين، نأخذ نسبة أكبر
-        if len(candidates) < 100:
-            target_count = min(len(candidates), 50)  # تأخذ على الأقل 50 مرشح إذا كان العدد الإجمالي قليل
-        
+        # نأخذ أفضل 50-100 مرشح للطبقة 2
+        target_count = min(max(50, len(candidates) // 3), 100, len(candidates))
         final_candidates = candidates[:target_count]
         
-        print(f"✅ تم اختيار {len(final_candidates)} عملة من أصل {len(candidates)} مرشح للطبقة 2")
+        print(f"✅ تم اختيار {len(final_candidates)} عملة من الطبقة 1")
         
         # عرض أفضل 10 مرشحين
         print("   🏆 أفضل 10 مرشحين من الطبقة 1:")
@@ -310,131 +259,144 @@ class DataManager:
         
         return final_candidates
 
-    async def _process_batch_rapid_screening_optimized(self, symbols_batch: List[str]) -> List[Dict[str, Any]]:
-        """معالجة دفعة من الرموز في الطبقة 1 بشكل متوازي ومحسن"""
+    async def _process_batch_rapid_screening(self, symbols_batch: List[str]) -> List[Dict[str, Any]]:
+        """معالجة دفعة من الرموز في الطبقة 1"""
         candidates = []
         
-        # استخدام asyncio.gather للمعالجة المتوازية
-        tasks = []
         for symbol in symbols_batch:
-            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)
+            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 >= 500000,      # تخفيف من 1M إلى 500K دولار
+                    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.2:  # تخفيف من 0.3 إلى 0.2
+                    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
+                await asyncio.sleep(2)  # انتظار في حالة rate limit
         
         return candidates
 
-    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
-            )
-            
-            # تخفيف عتبة القبول - تقليل من 0.3 إلى 0.1
-            if layer1_score >= 0.1:  # كان 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)
-                }
-                
-                return candidate_data
-            else:
-                return None
-                
-        except (asyncio.TimeoutError, Exception) as e:
-            # تجاهل الأخطاء والمتابعة
-            return None
+    def _calculate_volume_strength(self, dollar_volume: float) -> float:
+        """حساب قوة الحجم (بيانات فقط)"""
+        if dollar_volume >= 5000000:  # تخفيف من 10M إلى 5M
+            return 1.0
+        elif dollar_volume >= 2000000:  # تخفيف من 5M إلى 2M
+            return 0.8
+        elif dollar_volume >= 1000000:  # تخفيف من 2M إلى 1M
+            return 0.6
+        elif dollar_volume >= 500000:   # تخفيف من 1M إلى 500K
+            return 0.4
+        else:
+            return 0.2
 
-    def _quick_validation(self, current_price, dollar_volume, high_24h, low_24h):
-        """تحقق سريع من المعايير الأساسية - تخفيف الشروط"""
-        return all([
-            dollar_volume >= 500000,      # تخفيف من 1M إلى 500K دولار
-            current_price > 0.00000001,   # أي سعر مقبول
-            current_price <= 100000,      # حد أقصى معقول
-            high_24h > 0,                 # بيانات سعر صالحة
-            low_24h > 0,
-            high_24h != low_24h           # تجنب الأسعار الثابتة
-        ])
+    def _calculate_price_momentum(self, price_change_24h: float) -> float:
+        """حساب زخم السعر (بيانات فقط)"""
+        if price_change_24h >= 10:  # تخفيف من 15 إلى 10
+            return 0.9
+        elif price_change_24h >= 5:   # تخفيف من 8 إلى 5
+            return 0.7
+        elif price_change_24h >= 2:   # تخفيف م�� 3 إلى 2
+            return 0.5
+        elif price_change_24h <= -10: # تخفيف من -15 إلى -10
+            return 0.8
+        elif price_change_24h <= -5:  # تخفيف من -8 إلى -5
+            return 0.6
+        elif price_change_24h <= -2:  # تخفيف من -3 إلى -2
+            return 0.4
+        else:
+            return 0.3
 
-    def _calculate_fast_layer1_score(self, dollar_volume, price_change, current_price, high_24h, low_24h):
-        """حساب سريع لدرجة الطبقة 1"""
-        # حساب مبسط للحجم (بدون تعقيد)
-        volume_score = min(dollar_volume / 2000000, 1.0)  # تخفيف من 5M إلى 2M
+    def _calculate_price_position(self, current_price: float, high_24h: float, low_24h: float) -> float:
+        """حساب موقع السعر (بيانات فقط)"""
+        if high_24h == low_24h:
+            return 0.5
         
-        # حساب مبكر للزخم
-        if price_change >= 10:  # تخفيف من 15 إلى 10
-            momentum_score = 0.9
-        elif price_change >= 5:  # تخفيف من 8 إلى 5
-            momentum_score = 0.7
-        elif price_change >= 2:  # تخفيف من 3 إلى 2
-            momentum_score = 0.5
-        elif price_change <= -10:  # تخفيف من -15 إلى -10
-            momentum_score = 0.8  # فرصة شراء في الانخفاض
-        elif price_change <= -5:  # تخفيف من -8 إلى -5
-            momentum_score = 0.6
-        elif price_change <= -2:  # تخفيف من -3 إلى -2
-            momentum_score = 0.4
-        else:
-            momentum_score = 0.3
+        position = (current_price - low_24h) / (high_24h - low_24h)
         
-        # حساب موقع السعر بشكل مبسط
-        if high_24h != low_24h:
-            position = (current_price - low_24h) / (high_24h - low_24h)
-            if position < 0.2:  # كان 0.3
-                position_score = 0.8
-            elif position > 0.8:  # كان 0.7
-                position_score = 0.6
-            else:
-                position_score = 0.5
+        if position < 0.2:  # تخفيف من 0.3 إلى 0.2
+            return 0.8
+        elif position > 0.8:  # تخفيف من 0.7 إلى 0.8
+            return 0.6
         else:
-            position_score = 0.5
+            return 0.5
+
+    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
         
-        # الدرجة النهائية المبسطة
-        return (volume_score * 0.4 + momentum_score * 0.4 + position_score * 0.2)
+        if volatility > 0.3:  # تخفيف من 0.5 إلى 0.3
+            return 0.2
+        elif volatility > 0.15:  # تخفيف من 0.2 إلى 0.15
+            return 0.4
+        elif volatility > 0.08:  # تخفيف من 0.1 إلى 0.08
+            return 0.8
+        elif volatility > 0.04:  # تخفيف من 0.05 إلى 0.04
+            return 0.6
+        else:
+            return 0.3
 
-    def _generate_fast_reasons(self, dollar_volume, price_change):
-        """توليد أسباب سريعة"""
+    def _generate_layer1_reasons(self, volume_strength: float, price_momentum: float, 
+                               dollar_volume: float, price_change: float) -> List[str]:
+        """توليد أسباب الترشيح بناءً على البيانات فقط"""
         reasons = []
         
-        if dollar_volume >= 2000000:  # تخفيف من 5M إلى 2M
-            reasons.append('very_high_volume')
-        elif dollar_volume >= 1000000:  # تخفيف من 2M إلى 1M
-            reasons.append('high_volume')
-        else:
+        if volume_strength >= 0.6:
+            reasons.append('high_liquidity')
+        elif volume_strength >= 0.4:
             reasons.append('good_liquidity')
             
         if price_change >= 5:  # تخفيف من 8 إلى 5
@@ -446,88 +408,84 @@ class DataManager:
         elif price_change <= -2:  # تخفيف من -3 إلى -2
             reasons.append('dip_opportunity')
             
+        if dollar_volume >= 2000000:  # تخفيف من 5M إلى 2M
+            reasons.append('very_high_volume')
+        elif dollar_volume >= 1000000:  # تخفيف من 2M إلى 1M
+            reasons.append('high_volume')
+            
         return reasons
 
     async def get_ohlcv_data_for_symbols(self, symbols: List[str]) -> List[Dict[str, Any]]:
         """
-        جلب بيانات OHLCV كاملة للرموز المحددة بشكل متواز ومحسن
+        جلب بيانات OHLCV كاملة للرموز المحددة
+        يستخدم في الطبقة 2 للتحليل المتقدم
         """
         results = []
         
         print(f"📊 جلب بيانات OHLCV لـ {len(symbols)} عملة...")
         
-        # استخدام المهام المتوازية لجلب ا��بيانات مع إعادة المحاولة
-        tasks = []
         for symbol in symbols:
-            task = asyncio.create_task(self._fetch_ohlcv_with_retry(symbol))
-            tasks.append(task)
-        
-        # جمع النتائج مع معالجة الأخطاء
-        completed_tasks = await asyncio.gather(*tasks, return_exceptions=True)
-        
-        for result in completed_tasks:
-            if isinstance(result, Exception) or result is None:
+            try:
+                ohlcv_data = await self._fetch_ohlcv_for_symbol_safe(symbol)
+                if ohlcv_data:
+                    results.append(ohlcv_data)
+                    print(f"   ✅ تم جلب بيانات {symbol}")
+                else:
+                    print(f"   ❌ فشل جلب بيانات {symbol}")
+                
+                await asyncio.sleep(0.5)  # زيادة وقت الانتظار بين الطلبات
+                
+            except Exception as symbol_error:
+                print(f"❌ خطأ في جلب بيانات {symbol}: {symbol_error}")
                 continue
-            results.append(result)
-        
-        print(f"✅ تم تجميع بيانات OHLCV لـ {len(results)} عملة من أصل {len(symbols)}")
-        
-        if len(results) < len(symbols):
-            print(f"⚠️  فشل جلب بيانات {len(symbols) - len(results)} عملة")
         
+        print(f"✅ تم تجميع بيانات OHLCV لـ {len(results)} عملة")
         return results
 
-    async def _fetch_ohlcv_with_retry(self, symbol: str, max_retries: int = 3):
-        """جلب بيانات OHLCV مع إعادة المحاولة"""
-        for attempt in range(max_retries):
-            try:
-                result = await self._fetch_ohlcv_for_symbol(symbol)
-                if result:
-                    return result
-                else:
-                    await asyncio.sleep(1)  # انتظار قبل إعادة المحاولة
-            except Exception as e:
-                if attempt < max_retries - 1:
-                    await asyncio.sleep(1)
-                    continue
-                else:
-                    print(f"❌ فشل جلب بيانات {symbol} بعد {max_retries} محاولات: {e}")
-        return None
-
-    async def _fetch_ohlcv_for_symbol(self, symbol: str):
-        """جلب بيانات OHLCV لرمز واحد"""
+    async def _fetch_ohlcv_for_symbol_safe(self, symbol: str) -> Dict[str, Any]:
+        """جلب بيانات OHLCV لرمز واحد بشكل آمن"""
         try:
             ohlcv_data = {}
-            # تقليل عدد الإطارات الزمنية لتسريع العملية
+            
+            # استخدام إطارات زمنية أساسية فقط لتقليل الطلبات
             timeframes = [
-                ('1h', 50),  # إطار ساعة واحد فقط للبيانات الأساسية
-                ('4h', 30),  # إطار 4 ساعات
-                ('1d', 20),  # إطار يومي
+                ('1h', 50),  # ساعة واحدة - أساسي
+                ('4h', 25),  # 4 ساعات
+                ('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=10  # زيادة المهلة
+                        timeout=15  # زيادة المهلة
                     )
-                    if ohlcv and len(ohlcv) >= 10:  # تقليل الحد الأدنى
+                    
+                    if ohlcv and len(ohlcv) >= 10:  # تخفيف الحد الأدنى
                         ohlcv_data[timeframe] = ohlcv
                     else:
+                        print(f"   ⚠️  بيانات غير كافية لـ {symbol} على الإطار {timeframe}")
                         has_sufficient_data = False
                         break
-                except (asyncio.TimeoutError, Exception) as e:
-                    print(f"⚠️  خطأ في جلب بيانات {timeframe} لـ {symbol}: {e}")
+                        
+                except asyncio.TimeoutError:
+                    print(f"   ⏰ مهلة جلب بيانات {symbol} على الإطار {timeframe}")
+                    has_sufficient_data = False
+                    break
+                except Exception as e:
+                    print(f"   ⚠️  خطأ في جلب بيانات {symbol} على الإطار {timeframe}: {e}")
                     has_sufficient_data = False
                     break
             
-            if has_sufficient_data and ohlcv_data:  # التأكد من وجود بيانات
-                # جلب السعر الحالي بشكل منفصل
+            if has_sufficient_data and ohlcv_data:
+                # الحصول على بيانات التداول الحالية
                 try:
                     ticker = await asyncio.wait_for(
                         self.exchange.fetch_ticker(symbol),
-                        timeout=5
+                        timeout=10
                     )
                     current_price = ticker.get('last', 0) if ticker else 0
                     
@@ -538,13 +496,13 @@ class DataManager:
                         'timestamp': datetime.now().isoformat()
                     }
                 except Exception as price_error:
-                    print(f"⚠️  خطأ في جلب السعر لـ {symbol}: {price_error}")
+                    print(f"   ⚠️  خطأ في جلب السعر لـ {symbol}: {price_error}")
                     return None
             else:
                 return None
                 
-        except Exception as symbol_error:
-            print(f"⚠️  خطأ عام في جلب بيانات {symbol}: {symbol_error}")
+        except Exception as e:
+            print(f"   ❌ خطأ عام في جلب بيانات {symbol}: {e}")
             return None
 
     async def get_latest_price_async(self, symbol):
@@ -553,10 +511,7 @@ class DataManager:
             if not self.exchange:
                 return None
 
-            ticker = await asyncio.wait_for(
-                self.exchange.fetch_ticker(symbol),
-                timeout=5
-            )
+            ticker = await self.exchange.fetch_ticker(symbol)
             current_price = ticker.get('last')
             
             if current_price:
@@ -565,6 +520,7 @@ class DataManager:
                 return None
             
         except Exception as e:
+            print(f"❌ خطأ في جلب السعر لـ {symbol}: {e}")
             return None
 
     async def get_available_symbols(self):
@@ -602,10 +558,4 @@ class DataManager:
             print(f"❌ خطأ في التحقق من الرمز {symbol}: {e}")
             return False
 
-    def clear_cache(self):
-        """مسح الذاكرة المؤقتة"""
-        self.symbol_cache.clear()
-        self.cache_timestamp.clear()
-        print("✅ تم مسح الذاكرة المؤقتة")
-
-print("✅ DataManager loaded - Optimized for high performance screening")
+print("✅ DataManager loaded - Optimized for OHLCV data retrieval")