Update data_manager.py

data_manager.py

@@ -5,7 +5,7 @@ import httpx
 import traceback
 import time
 from datetime import datetime
-import ccxt.pro as ccxt
+import ccxt  # استخدام ccxt العادي بدلاً من pro
 import numpy as np
 import logging
 from typing import List, Dict, Any
@@ -19,18 +19,17 @@ class DataManager:
         self.whale_monitor = whale_monitor
         
         # إعدادات الأداء المحسنة
-        self.batch_size = 50  # تخفيض حجم الدفعة لتجنب rate limits
+        self.batch_size = 25  # حجم دفعة معقول
         self.cache_duration = 300
         
         try:
             self.exchange = ccxt.kucoin({
                 'sandbox': False,
                 'enableRateLimit': True,
-                'timeout': 30000,  # زيادة المهلة
+                'timeout': 30000,
                 'verbose': False,
-                'rateLimit': 1000,  # زيادة معدل الطلبات
             })
-            print("✅ تم تهيئة اتصال KuCoin بنجاح")
+            print("✅ تم تهيئة اتصال KuCoin بنجاح (CCXT Standard)")
         except Exception as e:
             print(f"❌ فشل تهيئة اتصال KuCoin: {e}")
             self.exchange = None
@@ -44,7 +43,7 @@ class DataManager:
     async def initialize(self):
         self.http_client = httpx.AsyncClient(timeout=30.0)
         await self._load_markets()
-        print("✅ DataManager initialized - Optimized for OHLCV data retrieval")
+        print("✅ DataManager initialized - Focused on Top 200 Symbols")
 
     async def _load_markets(self):
         try:
@@ -52,7 +51,7 @@ class DataManager:
                 return
                 
             print("🔄 جلب أحدث بيانات الأسواق من KuCoin...")
-            await self.exchange.load_markets()
+            self.exchange.load_markets()  # sync call instead of await
             self.market_cache = self.exchange.markets
             self.last_market_load = datetime.now()
             print(f"✅ تم تحميل {len(self.market_cache)} سوق من KuCoin")
@@ -63,8 +62,7 @@ class DataManager:
     async def close(self):
         if self.http_client: 
             await self.http_client.aclose()
-        if self.exchange:
-            await self.exchange.close()
+        # لا داعي لـ close في ccxt العادي
 
     async def get_market_context_async(self):
         """جلب سياق السوق الأساسي فقط"""
@@ -167,12 +165,12 @@ class DataManager:
         try:
             prices = {'bitcoin': None, 'ethereum': None}
             
-            btc_ticker = await self.exchange.fetch_ticker('BTC/USDT')
+            btc_ticker = self.exchange.fetch_ticker('BTC/USDT')  # sync call
             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
             
-            eth_ticker = await self.exchange.fetch_ticker('ETH/USDT')
+            eth_ticker = self.exchange.fetch_ticker('ETH/USDT')  # sync call
             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
@@ -217,10 +215,9 @@ class DataManager:
 
     async def layer1_rapid_screening(self) -> List[Dict[str, Any]]:
         """
-        الطبقة 1: فحص سريع لجميع عملات KuCoin
-        يركز فقط على جلب البيانات الأساسية بدون تحليل متقدم
+        الطبقة 1: فحص سريع لأفضل 200 عملة بناءً على مؤشرات هامة
         """
-        candidates = []
+        print("📊 الطبقة 1: فحص سريع لأفضل العملات بناءً على مؤشرات هامة...")
         
         # الحصول على جميع الرموز النشطة
         usdt_symbols = [
@@ -228,265 +225,284 @@ class DataManager:
             if symbol.endswith('/USDT') and self.market_cache[symbol].get('active', False)
         ]
         
-        print(f"📊 الطبقة 1: فحص سريع لـ {len(usdt_symbols)} عملة في KuCoin...")
+        print(f"🔍 تحليل {len(usdt_symbols)} عملة متاحة...")
         
-        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}...")
+        # جلب بيانات التداول لجميع الرموز وتقييمها
+        all_symbols_data = []
+        
+        for i, symbol in enumerate(usdt_symbols):
+            try:
+                symbol_data = await self._get_symbol_trading_data(symbol)
+                if symbol_data:
+                    all_symbols_data.append(symbol_data)
+                    
+                if i % 50 == 0:
+                    print(f"   📈 معالجة {i}/{len(usdt_symbols)} عملة...")
+                    
+                await asyncio.sleep(0.05)  # وقت انتظار قصير جداً
+                
+            except Exception as e:
+                continue
+        
+        print(f"✅ تم جمع بيانات {len(all_symbols_data)} عملة")
+        
+        if not all_symbols_data:
+            return []
+        
+        # تصنيف العملات بناءً على مؤشرات هامة
+        scored_symbols = []
+        
+        for symbol_data in all_symbols_data:
+            try:
+                score = self._calculate_comprehensive_score(symbol_data)
+                if score > 0:  # قبول العملات ذات الدرجة الإيجابية فقط
+                    symbol_data['layer1_score'] = score
+                    scored_symbols.append(symbol_data)
+            except Exception as e:
+                continue
+        
+        # ترتيب العملات حسب الدرجة (من الأعلى للأدنى)
+        scored_symbols.sort(key=lambda x: x.get('layer1_score', 0), reverse=True)
+        
+        # أخذ أفضل 200 عملة فقط
+        top_200 = scored_symbols[:200]
+        
+        print(f"🎯 تم اختيار أفضل {len(top_200)} عملة للطبقة 2")
+        
+        # عرض أفضل 15 عملة
+        print("🏆 أفضل 15 عملة من الطبقة 1:")
+        for i, symbol_data in enumerate(top_200[:15]):
+            score = symbol_data.get('layer1_score', 0)
+            volume = symbol_data.get('dollar_volume', 0)
+            change = symbol_data.get('price_change_24h', 0)
+            volatility = symbol_data.get('volatility_score', 0)
+            print(f"   {i+1:2d}. {symbol_data['symbol']}: {score:.3f} | ${volume:>8,.0f} | {change:>+6.1f}% | تقلب: {volatility:.3f}")
+        
+        return top_200
+
+    async def _get_symbol_trading_data(self, symbol: str) -> Dict[str, Any]:
+        """جلب بيانات التداول لرمز واحد"""
+        try:
+            ticker = self.exchange.fetch_ticker(symbol)
+            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) or 0
+            high_24h = ticker.get('high', 0)
+            low_24h = ticker.get('low', 0)
+            open_price = ticker.get('open', 0)
+            
+            # حساب مؤشرات إضافية هامة
+            volatility = self._calculate_volatility_score(high_24h, low_24h, current_price)
+            volume_trend = self._calculate_volume_trend(dollar_volume)
+            price_strength = self._calculate_price_strength(current_price, open_price, price_change_24h)
             
-            batch_candidates = await self._process_batch_rapid_screening(batch)
-            candidates.extend(batch_candidates)
+            return {
+                '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,
+                'open_price': open_price,
+                'volatility_score': volatility,
+                'volume_trend': volume_trend,
+                'price_strength': price_strength,
+                'reasons': []
+            }
             
-            await asyncio.sleep(1)  # زيادة وقت الانتظار بين الدفعات
+        except Exception as e:
+            return None
+
+    def _calculate_comprehensive_score(self, symbol_data: Dict[str, Any]) -> float:
+        """حساب درجة شاملة تعتمد على مؤشرات هامة للربحية"""
         
-        # ترتيب المرشحين حسب قوة الأساسيات
-        candidates.sort(key=lambda x: x.get('layer1_score', 0), reverse=True)
+        dollar_volume = symbol_data.get('dollar_volume', 0)
+        price_change = symbol_data.get('price_change_24h', 0)
+        volatility = symbol_data.get('volatility_score', 0)
+        volume_trend = symbol_data.get('volume_trend', 0)
+        price_strength = symbol_data.get('price_strength', 0)
         
-        # نأخذ أفضل 50-100 مرشح للطبقة 2
-        target_count = min(max(50, len(candidates) // 3), 100, len(candidates))
-        final_candidates = candidates[:target_count]
+        # 1. السيولة والحجم (35%) - الأهم لتجنب العملات الميتة
+        if dollar_volume < 100000:  # أقل من 100K دولار - رفض
+            return 0
         
-        print(f"✅ تم اختيار {len(final_candidates)} عملة من الطبقة 1")
+        volume_score = 0
+        if dollar_volume >= 10000000:    # 10M+ 
+            volume_score = 1.0
+        elif dollar_volume >= 5000000:   # 5M+
+            volume_score = 0.9
+        elif dollar_volume >= 2000000:   # 2M+
+            volume_score = 0.8
+        elif dollar_volume >= 1000000:   # 1M+
+            volume_score = 0.7
+        elif dollar_volume >= 500000:    # 500K+
+            volume_score = 0.6
+        elif dollar_volume >= 250000:    # 250K+
+            volume_score = 0.5
+        elif dollar_volume >= 100000:    # 100K+
+            volume_score = 0.4
         
-        # عرض أفضل 10 مرشحين
-        print("   🏆 أفضل 10 مرشحين من الطبقة 1:")
-        for i, candidate in enumerate(final_candidates[:10]):
-            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}%")
+        # 2. الزخم السعري (25%) - البحث عن حركة قوية
+        momentum_score = 0
+        if price_change >= 20:           # +20%+ - قوي جداً
+            momentum_score = 1.0
+        elif price_change >= 15:         # +15%+
+            momentum_score = 0.9
+        elif price_change >= 10:         # +10%+
+            momentum_score = 0.8
+        elif price_change >= 5:          # +5%+
+            momentum_score = 0.7
+        elif price_change >= 2:          # +2%+
+            momentum_score = 0.6
+        elif price_change >= 0:          # موجب
+            momentum_score = 0.5
+        elif price_change >= -5:         # حتى -5% (فرصة شراء)
+            momentum_score = 0.4
+        elif price_change >= -10:        # حتى -10%
+            momentum_score = 0.3
+        else:                            # أكثر من -10% - تجنب
+            momentum_score = 0.1
         
-        return final_candidates
-
-    async def _process_batch_rapid_screening(self, symbols_batch: List[str]) -> List[Dict[str, Any]]:
-        """معالجة دفعة من الرموز في الطبقة 1"""
-        candidates = []
+        # 3. التقلب المناسب (20%) - ليس عالي جداً ولا منخفض جداً
+        volatility_score = 0
+        if 0.02 <= volatility <= 0.15:   # تقلب مثالي 2%-15%
+            volatility_score = 1.0
+        elif 0.01 <= volatility <= 0.20: # مقبول 1%-20%
+            volatility_score = 0.8
+        elif volatility <= 0.01:         # قليل جداً
+            volatility_score = 0.3
+        elif volatility > 0.20:          # عالي جداً
+            volatility_score = 0.2
         
-        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 >= 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
+        # 4. قوة السعر (20%) - مزيج من الاتجاه والقوة
+        strength_score = price_strength
+        
+        # الدرجة النهائية
+        final_score = (
+            volume_score * 0.35 +
+            momentum_score * 0.25 +
+            volatility_score * 0.20 +
+            strength_score * 0.20
+        )
+        
+        # تحديث أسباب الترشيح
+        reasons = []
+        if volume_score >= 0.7:
+            reasons.append('high_liquidity')
+        if momentum_score >= 0.7:
+            reasons.append('strong_momentum')
+        if volatility_score >= 0.8:
+            reasons.append('optimal_volatility')
+        if strength_score >= 0.7:
+            reasons.append('price_strength')
+            
+        symbol_data['reasons'] = reasons
         
-        return candidates
+        return final_score
+
+    def _calculate_volatility_score(self, high_24h: float, low_24h: float, current_price: float) -> float:
+        """حساب درجة التقلب"""
+        if current_price == 0:
+            return 0
+        return (high_24h - low_24h) / current_price
 
-    def _calculate_volume_strength(self, dollar_volume: float) -> float:
-        """حساب قوة الحجم (بيانات فقط)"""
-        if dollar_volume >= 5000000:  # تخفيف من 10M إلى 5M
+    def _calculate_volume_trend(self, dollar_volume: float) -> float:
+        """حساب اتجاه الحجم"""
+        if dollar_volume >= 10000000:
             return 1.0
-        elif dollar_volume >= 2000000:  # تخفيف من 5M إلى 2M
+        elif dollar_volume >= 5000000:
             return 0.8
-        elif dollar_volume >= 1000000:  # تخفيف من 2M إلى 1M
+        elif dollar_volume >= 1000000:
             return 0.6
-        elif dollar_volume >= 500000:   # تخفيف من 1M إلى 500K
+        elif dollar_volume >= 500000:
             return 0.4
-        else:
+        elif dollar_volume >= 100000:
             return 0.2
-
-    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
+            return 0.1
 
-    def _calculate_price_position(self, current_price: float, high_24h: float, low_24h: float) -> float:
-        """حساب موقع السعر (بيانات فقط)"""
-        if high_24h == low_24h:
+    def _calculate_price_strength(self, current_price: float, open_price: float, price_change: float) -> float:
+        """حساب قوة السعر"""
+        if open_price == 0:
             return 0.5
         
-        position = (current_price - low_24h) / (high_24h - low_24h)
+        # قوة السعر تعتمد على المسافة من سعر الافتتاح ونسبة التغير
+        distance_from_open = abs(current_price - open_price) / open_price
+        change_strength = min(abs(price_change) / 50, 1.0)  # تطبيع قوة التغير
         
-        if position < 0.2:  # تخفيف من 0.3 إلى 0.2
-            return 0.8
-        elif position > 0.8:  # تخفيف من 0.7 إلى 0.8
-            return 0.6
-        else:
-            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
-        
-        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_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 >= 5:  # تخفيف من 8 إلى 5
-            reasons.append('strong_positive_momentum')
-        elif price_change >= 2:  # تخفيف من 3 إلى 2
-            reasons.append('positive_momentum')
-        elif price_change <= -5:  # تخفيف من -8 إلى -5
-            reasons.append('oversold_opportunity')
-        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
+        return (distance_from_open * 0.6 + change_strength * 0.4)
 
     async def get_ohlcv_data_for_symbols(self, symbols: List[str]) -> List[Dict[str, Any]]:
         """
-        جلب بيانات OHLCV كاملة للرموز المحددة
-        يستخدم في الطبقة 2 للتحليل المتقدم
+        جلب بيانات OHLCV كاملة للرموز المحددة مع جميع الإطارات الزمنية الـ6
         """
         results = []
         
-        print(f"📊 جلب بيانات OHLCV لـ {len(symbols)} عملة...")
+        print(f"📊 جلب بيانات OHLCV كاملة لـ {len(symbols)} عملة...")
+        print("   📈 الإطارات الزمنية: 5m, 15m, 1h, 4h, 1d, 1w")
         
-        for symbol in symbols:
+        for i, symbol in enumerate(symbols):
             try:
-                ohlcv_data = await self._fetch_ohlcv_for_symbol_safe(symbol)
+                ohlcv_data = await self._fetch_complete_ohlcv(symbol)
                 if ohlcv_data:
                     results.append(ohlcv_data)
-                    print(f"   ✅ تم جلب بيانات {symbol}")
+                    print(f"   ✅ ({i+1}/{len(symbols)}) تم جلب بيانات {symbol}")
                 else:
-                    print(f"   ❌ فشل جلب بيانات {symbol}")
+                    print(f"   ❌ ({i+1}/{len(symbols)}) فشل جلب بيانات {symbol}")
                 
-                await asyncio.sleep(0.5)  # زيادة وقت الانتظار بين الطلبات
+                # وقت انتظار لتجنب rate limits
+                await asyncio.sleep(0.3)
                 
             except Exception as symbol_error:
-                print(f"❌ خطأ في جلب بيانات {symbol}: {symbol_error}")
+                print(f"   ❌ ({i+1}/{len(symbols)}) خطأ في {symbol}: {symbol_error}")
                 continue
         
-        print(f"✅ تم تجميع بيانات OHLCV لـ {len(results)} عملة")
+        print(f"✅ تم تجميع بيانات OHLCV كاملة لـ {len(results)} عملة")
         return results
 
-    async def _fetch_ohlcv_for_symbol_safe(self, symbol: str) -> Dict[str, Any]:
-        """جلب بيانات OHLCV لرمز واحد بشكل آمن"""
+    async def _fetch_complete_ohlcv(self, symbol: str) -> Dict[str, Any]:
+        """جلب بيانات OHLCV كاملة مع جميع الإطارات الزمنية الـ6"""
         try:
             ohlcv_data = {}
             
-            # استخدام إطارات زمنية أساسية فقط لتقليل الطلبات
+            # جميع الإطارات الزمنية الـ6 المطلوبة
             timeframes = [
-                ('1h', 50),  # ساعة واحدة - أساسي
-                ('4h', 25),  # 4 ساعات
-                ('1d', 30),  # يومي
+                ('5m', 100),   # 5 دقائق - 100 شمعة
+                ('15m', 100),  # 15 دقيقة - 100 شمعة
+                ('1h', 100),   # 1 ساعة - 100 شمعة
+                ('4h', 100),   # 4 ساعات - 100 شمعة
+                ('1d', 100),   # 1 يوم - 100 شمعة
+                ('1w', 50),    # 1 أسبوع - 50 شمعة
             ]
             
             has_sufficient_data = True
             
             for timeframe, limit in timeframes:
                 try:
-                    # زيادة المهلة وجعل الطلبات أكثر موثوقية
-                    ohlcv = await asyncio.wait_for(
-                        self.exchange.fetch_ohlcv(symbol, timeframe, limit=limit),
-                        timeout=15  # زيادة المهلة
-                    )
+                    # استخدام fetch_ohlcv العادي (ليس pro)
+                    ohlcv = self.exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
                     
-                    if ohlcv and len(ohlcv) >= 10:  # تخفيف الحد الأدنى
+                    if ohlcv and len(ohlcv) >= 20:  # تأكد من وجود بيانات كافية
                         ohlcv_data[timeframe] = ohlcv
                     else:
-                        print(f"   ⚠️  بيانات غير كافية لـ {symbol} على الإطار {timeframe}")
+                        print(f"      ⚠️  بيانات غير كافية لـ {symbol} على {timeframe}")
                         has_sufficient_data = False
                         break
                         
-                except asyncio.TimeoutError:
-                    print(f"   ⏰ مهلة جلب بيانات {symbol} على الإطار {timeframe}")
-                    has_sufficient_data = False
-                    break
                 except Exception as e:
-                    print(f"   ⚠️  خطأ في جلب بيانات {symbol} على الإطار {timeframe}: {e}")
+                    print(f"      ⚠️  خطأ في {symbol} على {timeframe}: {e}")
                     has_sufficient_data = False
                     break
             
             if has_sufficient_data and ohlcv_data:
-                # الحصول على بيانات التداول الحالية
+                # جلب السعر الحالي
                 try:
-                    ticker = await asyncio.wait_for(
-                        self.exchange.fetch_ticker(symbol),
-                        timeout=10
-                    )
+                    ticker = self.exchange.fetch_ticker(symbol)
                     current_price = ticker.get('last', 0) if ticker else 0
                     
                     return {
@@ -496,13 +512,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 e:
-            print(f"   ❌ خطأ عام في جلب بيانات {symbol}: {e}")
+            print(f"      ❌ خطأ عام في {symbol}: {e}")
             return None
 
     async def get_latest_price_async(self, symbol):
@@ -511,7 +527,7 @@ class DataManager:
             if not self.exchange:
                 return None
 
-            ticker = await self.exchange.fetch_ticker(symbol)
+            ticker = self.exchange.fetch_ticker(symbol)
             current_price = ticker.get('last')
             
             if current_price:
@@ -558,4 +574,4 @@ class DataManager:
             print(f"❌ خطأ في التحقق من الرمز {symbol}: {e}")
             return False
 
-print("✅ DataManager loaded - Optimized for OHLCV data retrieval")
+print("✅ DataManager loaded - CCXT Standard with Top 200 Symbols & Full OHLCV Timeframes")