Update ml_engine/data_manager.py

ml_engine/data_manager.py

@@ -1,6 +1,6 @@
 # ============================================================
 # 📂 ml_engine/data_manager.py 
-# (V62.0 - GEM-Architect: Accumulation Depth & Vitality Check)
+# (V63.0 - GEM-Architect: High Volume Filter & Depth Scan)
 # ============================================================
 
 import asyncio
@@ -38,13 +38,13 @@ class DataManager:
         self.http_client = None
         self.market_cache = {}
         
-        # القائمة السوداء (نحتفظ بها كما هي لتجنب العملات القمامة فعلياً)
+        # القائمة السوداء
         self.BLACKLIST_TOKENS = [
             'USDT', 'USDC', 'DAI', 'TUSD', 'BUSD', 'FDUSD', 'EUR', 'PAX',
             'UP', 'DOWN', 'BEAR', 'BULL', '3S', '3L'
         ]
         
-        print(f"📦 [DataManager V62.0] Accumulation Depth & Vitality Check Active.")
+        print(f"📦 [DataManager V63.0] High Liquidity (1M+) & Depth Scan Active.")
 
     async def initialize(self):
         print("   > [DataManager] Starting initialization...")
@@ -77,15 +77,15 @@ class DataManager:
     # ==================================================================
     async def layer1_rapid_screening(self, adaptive_hub_ref=None) -> List[Dict[str, Any]]:
         self.adaptive_hub_ref = adaptive_hub_ref
-        print(f"🔍 [Layer 1] Screening for Safe Bottoms, Accumulation & Momentum...")
+        print(f"🔍 [Layer 1] Screening for High Vol Assets (Bottom/Acc/Mom)...")
         
-        # 1. فلتر السيولة الأساسي
+        # 1. فلتر السيولة الأساسي (الآن صارم: 1 مليون دولار)
         initial_candidates = await self._stage0_universe_filter()
         if not initial_candidates:
             print("⚠️ [Layer 1] Stage 0 returned 0 candidates.")
             return []
 
-        # 2. جلب البيانات الفنية (دفعة أكبر لزيادة الفرص)
+        # 2. جلب البيانات الفنية
         top_candidates = initial_candidates[:600] 
         enriched_data = await self._fetch_technical_data_batch(top_candidates)
         
@@ -96,81 +96,65 @@ class DataManager:
             classification = self._classify_opportunity_type(item)
             
             if classification['type'] != 'NONE':
-                # تشخيص حالة السوق
                 regime_info = self._diagnose_asset_regime(item)
                 item['asset_regime'] = regime_info['regime']
                 item['asset_regime_conf'] = regime_info['conf']
                 
-                # تخزين نوع الاستراتيجية والنتيجة الأولية
                 item['strategy_type'] = classification['type'] 
                 item['l1_sort_score'] = classification['score']
                 item['strategy_tag'] = classification['type']
                 
-                # فحص الـ Regime (نرفض الانفجارات في الأسواق الميتة، لكن نقبل التجميع)
+                # فحص الـ Regime
                 if regime_info['regime'] == 'DEAD' and classification['type'] == 'MOMENTUM_LAUNCH':
-                    # استثناء: إذا كان "Squeeze" (تجميع)، نسمح بمروره حتى لو السوق ميت
                     if not classification.get('is_squeeze', False):
                         continue
 
                 semi_final_list.append(item)
 
-        # 4. 🧱 فحص عمق السوق (Order Book Check) للمرشحين للتجميع
-        # هذا هو "مصدر الكشف" الجديد الذي طلبته
+        # 4. 🧱 فحص عمق السوق (Order Book Check)
         final_list = []
-        print(f"   🛡️ [Layer 1.5] Checking Depth Support for {len(semi_final_list)} candidates...")
-        
-        # نأخذ أفضل 50 مرشحاً فقط لفحص دفتر الطلبات لتجنب حظر API
+        # نأخذ أفضل 50 مرشحاً لفحص دفتر الطلبات
         semi_final_list.sort(key=lambda x: x['l1_sort_score'], reverse=True)
-        candidates_for_depth = semi_final_list[:150]
+        candidates_for_depth = semi_final_list[:50]
+        
+        if candidates_for_depth:
+            print(f"   🛡️ [Layer 1.5] Checking Depth Support for {len(candidates_for_depth)} candidates...")
         
         for item in candidates_for_depth:
-            # إذا كانت تجميع (Squeeze) أو قاع، نفحص هل هناك دعم حقيقي في الأسفل؟
             if item['strategy_type'] in ['ACCUMULATION_SQUEEZE', 'SAFE_BOTTOM']:
                 try:
-                    # حساب نطاق الساعتين القادمتين (2 * ATR)
                     atr_val = item.get('atr_value', 0.0)
                     curr_price = item.get('current_price', 0.0)
                     
                     if atr_val > 0 and curr_price > 0:
                         range_2h = atr_val * 2.0
-                        # فحص ضغط دفتر الطلبات في هذا النطاق
                         ob_score = await self._check_ob_pressure(item['symbol'], curr_price, range_2h)
                         
-                        # تعزيز النتيجة بناءً على دعم دفتر الطلبات
-                        if ob_score > 0.6: # دعم قوي
-                            item['l1_sort_score'] += 0.15 # بونص
+                        if ob_score > 0.6: 
+                            item['l1_sort_score'] += 0.15 
                             item['note'] = f"Strong Depth Support ({ob_score:.2f})"
-                        elif ob_score < 0.4: # دعم ضعيف
-                            item['l1_sort_score'] -= 0.10 # عقوبة
+                        elif ob_score < 0.4: 
+                            item['l1_sort_score'] -= 0.10 
                 except Exception: pass
             
-            # حقن الإعدادات الديناميكية
             if self.adaptive_hub_ref:
                 dynamic_config = self.adaptive_hub_ref.get_regime_config(item['asset_regime'])
                 item['dynamic_limits'] = dynamic_config
 
             final_list.append(item)
 
-        # 5. الترتيب النهائي والإرجاع
         final_list.sort(key=lambda x: x['l1_sort_score'], reverse=True)
-        selection = final_list[:150]
+        selection = final_list[:60]
         
-        print(f"✅ [Layer 1] Passed {len(selection)} candidates (With Depth Verification).")
+        print(f"✅ [Layer 1] Passed {len(selection)} active candidates.")
         return selection
 
     # ==================================================================
-    # 🧱 Order Book Depth Scanner (2-Hour Range Logic)
+    # 🧱 Order Book Depth Scanner
     # ==================================================================
     async def _check_ob_pressure(self, symbol: str, current_price: float, price_range: float) -> float:
-        """
-        يفحص دفتر الطلبات داخل النطاق السعري المتوقع للساعتين القادمتين.
-        النطاق = السعر الحالي +/- (ATR_1H * 2)
-        يعيد نسبة قوة المشترين (0.0 إلى 1.0).
-        """
         try:
-            # جلب لقطة سريعة لدفتر الطلبات (50 مستوى كافية للتجميع القريب)
             ob = await self.exchange.fetch_order_book(symbol, limit=50)
-            
             bids = ob['bids']
             asks = ob['asks']
             
@@ -180,43 +164,29 @@ class DataManager:
             support_vol = 0.0
             resistance_vol = 0.0
             
-            # تجميع طلبات الشراء داخل نطاق الدعم المتوقع
             for p, v in bids:
-                if p >= min_price:
-                    support_vol += v
-                else: break # بما أن Bids مرتبة تنازلياً
+                if p >= min_price: support_vol += v
+                else: break
                 
-            # تجميع طلبات البيع داخل نطاق المقاومة المتوقع
             for p, v in asks:
-                if p <= max_price:
-                    resistance_vol += v
-                else: break # بما أن Asks مرتبة تصاعدياً
+                if p <= max_price: resistance_vol += v
+                else: break
                 
             if (support_vol + resistance_vol) == 0: return 0.5
-            
-            # نسبة ضغط الشراء (Imbalance)
-            pressure_ratio = support_vol / (support_vol + resistance_vol)
-            return pressure_ratio
-            
+            return support_vol / (support_vol + resistance_vol)
         except Exception:
-            return 0.5 # حياد في حال الفشل
+            return 0.5
 
     # ==================================================================
-    # ⚖️ The Dual-Classifier Logic (GEM-Architect: ACCUMULATION UPGRADE)
+    # ⚖️ The Dual-Classifier Logic
     # ==================================================================
     def _classify_opportunity_type(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        تم التعديل ليشمل منطق التجميع (RSI 45-60) وفلتر الحياة (ATR).
-        """
         try:
             df_1h = self._calc_indicators(data['ohlcv_1h_raw'])
             curr = df_1h.iloc[-1]
-            
-            # تخزين ATR لاستخدامه لاحقاً في فحص دفتر الطلبات
             data['atr_value'] = curr['atr']
         except: return {'type': 'NONE', 'score': 0}
 
-        # --- المؤشرات الأساسية ---
         rsi = curr['rsi']
         close = curr['close']
         ema20 = curr['ema20']
@@ -224,40 +194,29 @@ class DataManager:
         ema200 = curr['ema200'] if 'ema200' in curr else ema50 
         atr = curr['atr']
         
-        # Bollinger Bands
         lower_bb = curr['lower_bb'] if 'lower_bb' in curr else (curr['ema20'] - (2*curr['atr']))
         upper_bb = curr['upper_bb'] if 'upper_bb' in curr else (curr['ema20'] + (2*curr['atr']))
         bb_width = (upper_bb - lower_bb) / curr['ema20'] if curr['ema20'] > 0 else 1.0
 
-        # 🔥 1. Dead Coin Filter (فلتر العملات الميتة)
-        # نحسب نسبة الـ ATR للسعر. إذا كانت الحركة أقل من 0.4% في الساعة، نرفضها.
+        # 🔥 1. Dead Coin Filter (فلتر النبض)
         volatility_pct = (atr / close) * 100 if close > 0 else 0
-        if volatility_pct < 0.4:
-            return {'type': 'NONE', 'score': 0}
+        if volatility_pct < 0.4: return {'type': 'NONE', 'score': 0}
 
-        # 🛡️ TYPE 1: SAFE_BOTTOM (RSI < 45)
+        # 🛡️ TYPE 1: SAFE_BOTTOM
         if rsi < 45:
             dist_from_ema = (ema50 - close) / ema50
-            # السماح بمسافة أكبر قليلاً عن الخط السفلي (5%)
             if close <= lower_bb * 1.05 and dist_from_ema > 0.015:
                 score = (55 - rsi) / 20.0 
                 return {'type': 'SAFE_BOTTOM', 'score': min(score, 1.0)}
 
-        # 🔋 TYPE 2: ACCUMULATION_SQUEEZE (The Missing Link)
-        # المنطق: RSI محايد (45-60) + قناة ضيقة (Squeeze) + دعم دفتر الطلبات (سيفحص لاحقاً)
+        # 🔋 TYPE 2: ACCUMULATION_SQUEEZE
         elif 45 <= rsi <= 60:
-            if bb_width < 0.12: # وسعنا النطاق قليلاً لـ 12% لزيادة المرونة
-                # نفضل أن يكون السعر يحاول الصعود فوق متوسط 20
-                if close > ema20 * 0.995: # السماح بكسر وهمي بسيط
+            if bb_width < 0.12:
+                if close > ema20 * 0.995:
                     score = 1.0 - (bb_width * 4.0) 
-                    # نستخدم وسم خاص لتمييزها
-                    return {
-                        'type': 'ACCUMULATION_SQUEEZE', 
-                        'score': max(score, 0.5),
-                        'is_squeeze': True
-                    }
+                    return {'type': 'ACCUMULATION_SQUEEZE', 'score': max(score, 0.5), 'is_squeeze': True}
 
-        # 🚀 TYPE 3: MOMENTUM_LAUNCH (Classic)
+        # 🚀 TYPE 3: MOMENTUM_LAUNCH
         elif 60 < rsi < 80:
             if close > ema50 and close > ema200:
                 dist_to_upper = (upper_bb - close) / close
@@ -268,16 +227,18 @@ class DataManager:
         return {'type': 'NONE', 'score': 0}
 
     # ==================================================================
-    # 🔍 Stage 0: Universe Filter (RELAXED USD CALC)
+    # 🔍 Stage 0: Universe Filter (STRICT 1M FILTER)
     # ==================================================================
     async def _stage0_universe_filter(self) -> List[Dict[str, Any]]:
         try:
-            print("   🛡️ [Stage 0] Fetching Tickers (Accumulation Mode)...")
+            # 🔥 إعداد الحد الأدنى لحجم التداول (يمكنك تغييره إلى 5 مليون من هنا)
+            MIN_VOLUME_THRESHOLD = 1000000.0  # 1 Million USDT
+            
+            print(f"   🛡️ [Stage 0] Fetching Tickers (Min Vol: ${MIN_VOLUME_THRESHOLD:,.0f})...")
             tickers = await self.exchange.fetch_tickers()
             candidates = []
             
             SOVEREIGN_COINS = ['BTC/USDT', 'ETH/USDT', 'SOL/USDT', 'BNB/USDT', 'XRP/USDT']
-            
             reject_stats = {"volume": 0, "change": 0, "blacklist": 0}
 
             for symbol, ticker in tickers.items():
@@ -294,9 +255,9 @@ class DataManager:
                 
                 is_sovereign = symbol in SOVEREIGN_COINS
                 
-                # تخفيف فلتر السيولة للسماح بعملات التجميع الصغيرة
+                # 🔥 الفلتر الصارم الجديد: رفض أي عملة تحت المليون
                 if not is_sovereign:
-                    if calc_quote_vol < 150000: 
+                    if calc_quote_vol < MIN_VOLUME_THRESHOLD: 
                         reject_stats["volume"] += 1
                         continue
                 
@@ -315,6 +276,7 @@ class DataManager:
                 })
             
             candidates.sort(key=lambda x: x['quote_volume'], reverse=True)
+            print(f"   ℹ️ [Stage 0] Ignored {reject_stats['volume']} low-vol coins.")
             return candidates
             
         except Exception as e:
@@ -322,36 +284,6 @@ class DataManager:
             traceback.print_exc()
             return []
 
-    # ------------------------------------------------------------------
-    # 🧭 The Diagnoser
-    # ------------------------------------------------------------------
-    def _diagnose_asset_regime(self, item: Dict[str, Any]) -> Dict[str, Any]:
-        try:
-            if 'df_1h' not in item: return {'regime': 'RANGE', 'conf': 0.0}
-            df = item['df_1h']
-            curr = df.iloc[-1]
-            price = curr['close']
-            ema20 = curr['ema20']
-            ema50 = curr['ema50']
-            rsi = curr['rsi']
-            atr = curr['atr']
-            atr_pct = (atr / price) * 100 if price > 0 else 0
-            
-            regime = "RANGE"
-            conf = 0.5
-            
-            if atr_pct < 0.4: return {'regime': 'DEAD', 'conf': 0.9}
-            
-            if price > ema20 and ema20 > ema50 and rsi > 50:
-                regime = "BULL"
-                conf = 0.8 if rsi > 55 else 0.6
-            elif price < ema20 and ema20 < ema50 and rsi < 50:
-                regime = "BEAR"
-                conf = 0.8 if rsi < 45 else 0.6
-                
-            return {'regime': regime, 'conf': conf}
-        except Exception: return {'regime': 'RANGE', 'conf': 0.0}
-
     # ------------------------------------------------------------------
     # Helpers & Indicators
     # ------------------------------------------------------------------
@@ -393,7 +325,7 @@ class DataManager:
         tr = np.maximum(df['h']-df['l'], np.maximum(abs(df['h']-df['c'].shift()), abs(df['l']-df['c'].shift())))
         df['atr'] = tr.rolling(14).mean()
         
-        # Bollinger Bands (Standard: 20, 2)
+        # Bollinger Bands
         std = df['c'].rolling(20).std()
         df['upper_bb'] = df['ema20'] + (2 * std)
         df['lower_bb'] = df['ema20'] - (2 * std)