Update data_manager.py

data_manager.py

@@ -280,18 +280,29 @@ class DataManager:
             if i + self.batch_size < len(usdt_symbols):
                 await asyncio.sleep(0.1)  # تقليل وقت الانتظار
         
+        print(f"📊 تم جمع {len(candidates)} مرشح مؤهل من الطبقة 1")
+        
+        if not candidates:
+            print("❌ لم يتم العثور على أي مرشح مؤهل")
+            return []
+        
         # ترتيب المرشحين حسب قوة الأساسيات
         candidates.sort(key=lambda x: x.get('layer1_score', 0), reverse=True)
         
-        # نأخذ أفضل 80-180 مرشح للطبقة 2
-        target_count = min(max(80, len(candidates) // 5), 180)
+        # إصلاح الخطأ: تحديد عدد المرشحين بشكل صحيح
+        target_count = min(max(80, len(candidates) // 2), 180, len(candidates))
+        
+        # إذا كان لدينا عدد قليل من المرشحين، نأخذ نسبة أكبر
+        if len(candidates) < 100:
+            target_count = min(len(candidates), 50)  # تأخذ على الأقل 50 مرشح إذا كان العدد الإجمالي قليل
+        
         final_candidates = candidates[:target_count]
         
-        print(f"✅ تم اختيار {len(final_candidates)} عملة من الطبقة 1")
+        print(f"✅ تم اختيار {len(final_candidates)} عملة من أصل {len(candidates)} مرشح للطبقة 2")
         
-        # عرض أفضل 5 مرشحين
-        print("   🏆 أفضل 5 مرشحين من الطبقة 1:")
-        for i, candidate in enumerate(final_candidates[:5]):
+        # عرض أفضل 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)
@@ -306,13 +317,7 @@ class DataManager:
         # استخدام asyncio.gather للمعالجة المتوازية
         tasks = []
         for symbol in symbols_batch:
-            # التحقق من التخزين المؤقت أولاً
-            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)))
+            tasks.append(asyncio.create_task(self._process_symbol_optimized(symbol)))
         
         # انتظار اكتمال جميع المهام
         results = await asyncio.gather(*tasks, return_exceptions=True)
@@ -324,16 +329,6 @@ class DataManager:
         
         return candidates
 
-    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 await self._process_symbol_optimized(symbol)
-
     async def _process_symbol_optimized(self, symbol: str):
         """معالجة رمز واحد بشكل محسن"""
         try:
@@ -353,7 +348,7 @@ class DataManager:
             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
             
@@ -362,7 +357,8 @@ class DataManager:
                 dollar_volume, price_change_24h, current_price, high_24h, low_24h
             )
             
-            if layer1_score >= 0.3:
+            # تخفيف عتبة القبول - تقليل من 0.3 إلى 0.1
+            if layer1_score >= 0.1:  # كان 0.3
                 candidate_data = {
                     'symbol': symbol,
                     'current_price': current_price,
@@ -375,25 +371,18 @@ class DataManager:
                     '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:
-            # إصلاح الخطأ: است��دال continue بـ return None
-            if "rate limit" not in str(e).lower():
-                return None
+            # تجاهل الأخطاء والمتابعة
             return None
 
     def _quick_validation(self, current_price, dollar_volume, high_24h, low_24h):
-        """تحقق سريع من المعايير الأساسية"""
+        """تحقق سريع من المعايير الأساسية - تخفيف الشروط"""
         return all([
-            dollar_volume >= 1000000,      # حجم تداول لا يقل عن 1M دولار
+            dollar_volume >= 500000,      # تخفيف من 1M إلى 500K دولار
             current_price > 0.00000001,   # أي سعر مقبول
             current_price <= 100000,      # حد أقصى معقول
             high_24h > 0,                 # بيانات سعر صالحة
@@ -404,20 +393,20 @@ class DataManager:
     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
+        volume_score = min(dollar_volume / 2000000, 1.0)  # تخفيف من 5M إلى 2M
         
         # حساب مبكر للزخم
-        if price_change >= 15:
+        if price_change >= 10:  # تخفيف من 15 إلى 10
             momentum_score = 0.9
-        elif price_change >= 8:
+        elif price_change >= 5:  # تخفيف من 8 إلى 5
             momentum_score = 0.7
-        elif price_change >= 3:
+        elif price_change >= 2:  # تخفيف من 3 إلى 2
             momentum_score = 0.5
-        elif price_change <= -15:
+        elif price_change <= -10:  # تخفيف من -15 إلى -10
             momentum_score = 0.8  # فرصة شراء في الانخفاض
-        elif price_change <= -8:
+        elif price_change <= -5:  # تخفيف من -8 إلى -5
             momentum_score = 0.6
-        elif price_change <= -3:
+        elif price_change <= -2:  # تخفيف من -3 إلى -2
             momentum_score = 0.4
         else:
             momentum_score = 0.3
@@ -425,9 +414,9 @@ class DataManager:
         # حساب موقع السعر بشكل مبسط
         if high_24h != low_24h:
             position = (current_price - low_24h) / (high_24h - low_24h)
-            if position < 0.3:
+            if position < 0.2:  # كان 0.3
                 position_score = 0.8
-            elif position > 0.7:
+            elif position > 0.8:  # كان 0.7
                 position_score = 0.6
             else:
                 position_score = 0.5
@@ -441,75 +430,79 @@ class DataManager:
         """توليد أسباب سريعة"""
         reasons = []
         
-        if dollar_volume >= 5000000:
+        if dollar_volume >= 2000000:  # تخفيف من 5M إلى 2M
             reasons.append('very_high_volume')
-        elif dollar_volume >= 2000000:
+        elif dollar_volume >= 1000000:  # تخفيف من 2M إلى 1M
             reasons.append('high_volume')
         else:
             reasons.append('good_liquidity')
             
-        if price_change >= 8:
+        if price_change >= 5:  # تخفيف من 8 إلى 5
             reasons.append('strong_positive_momentum')
-        elif price_change >= 3:
+        elif price_change >= 2:  # تخفيف من 3 إلى 2
             reasons.append('positive_momentum')
-        elif price_change <= -8:
+        elif price_change <= -5:  # تخفيف من -8 إلى -5
             reasons.append('oversold_opportunity')
-        elif price_change <= -3:
+        elif price_change <= -2:  # تخفيف من -3 إلى -2
             reasons.append('dip_opportunity')
             
         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 كاملة للرموز المحددة بشكل متواز
+        جلب بيانات OHLCV كاملة للرموز المحددة بشكل متواز ومحسن
         """
         results = []
         
         print(f"📊 جلب بيانات OHLCV لـ {len(symbols)} عملة...")
         
-        # استخدام المهام المتوازية لجلب البيانات
+        # استخدام المهام المتوازية لجلب البيانات مع إعادة المحاولة
         tasks = []
         for symbol in symbols:
-            task = asyncio.create_task(self._fetch_ohlcv_for_symbol(symbol))
+            task = asyncio.create_task(self._fetch_ohlcv_with_retry(symbol))
             tasks.append(task)
         
-        # معالجة النتائج مع تحديد مهلة
-        for task in asyncio.as_completed(tasks, timeout=30):
-            try:
-                result = await task
-                if result:
-                    results.append(result)
-            except (asyncio.TimeoutError, Exception) as e:
+        # جمع النتائج مع معالجة الأخطاء
+        completed_tasks = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        for result in completed_tasks:
+            if isinstance(result, Exception) or result is None:
                 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 لرمز واحد"""
         try:
             ohlcv_data = {}
+            # تقليل عدد الإطارات الزمنية لتسريع العملية
             timeframes = [
-                ('5m', 50),  # تقليل عدد الشموع
-                ('15m', 50), 
-                ('1h', 50), 
-                ('4h', 50), 
-                ('1d', 30),  # تقليل للبيانات اليومية
+                ('1h', 50),  # إطار ساعة واحد فقط للبيانات الأساسية
+                ('4h', 30),  # إطار 4 ساعات
+                ('1d', 20),  # إطار يومي
             ]
             
             has_sufficient_data = True
@@ -517,35 +510,41 @@ class DataManager:
                 try:
                     ohlcv = await asyncio.wait_for(
                         self.exchange.fetch_ohlcv(symbol, timeframe, limit=limit),
-                        timeout=5
+                        timeout=10  # زيادة المهلة
                     )
-                    if ohlcv and len(ohlcv) >= 15:  # تقليل الحد الأدنى
+                    if ohlcv and len(ohlcv) >= 10:  # تقليل الحد الأدنى
                         ohlcv_data[timeframe] = ohlcv
                     else:
                         has_sufficient_data = False
                         break
-                except (asyncio.TimeoutError, Exception):
+                except (asyncio.TimeoutError, Exception) as e:
+                    print(f"⚠️  خطأ في جلب بيانات {timeframe} لـ {symbol}: {e}")
                     has_sufficient_data = False
                     break
             
-            if has_sufficient_data:
+            if has_sufficient_data and ohlcv_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()
-                }
+                try:
+                    ticker = await asyncio.wait_for(
+                        self.exchange.fetch_ticker(symbol),
+                        timeout=5
+                    )
+                    current_price = ticker.get('last', 0) if ticker else 0
+                    
+                    return {
+                        'symbol': symbol,
+                        'ohlcv': ohlcv_data,
+                        'current_price': current_price,
+                        'timestamp': datetime.now().isoformat()
+                    }
+                except Exception as price_error:
+                    print(f"⚠️  خطأ في جلب السعر لـ {symbol}: {price_error}")
+                    return None
             else:
                 return None
                 
         except Exception as symbol_error:
+            print(f"⚠️  خطأ عام في جلب بيانات {symbol}: {symbol_error}")
             return None
 
     async def get_latest_price_async(self, symbol):
@@ -554,24 +553,14 @@ class DataManager:
             if not self.exchange:
                 return None
 
-            # التحقق من التخزين المؤقت أولاً
-            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
+                timeout=5
             )
             current_price = ticker.get('last')
             
             if current_price:
-                price = float(current_price)
-                # تحديث التخزين المؤقت
-                self.symbol_cache[cache_key] = {'current_price': price}
-                self.cache_timestamp[cache_key] = time.time()
-                return price
+                return float(current_price)
             else:
                 return None