Update ml_engine/data_manager.py

ml_engine/data_manager.py

@@ -1,6 +1,6 @@
 # ============================================================
 # 📂 ml_engine/data_manager.py 
-# (V18.3 - GEM-Architect: Adaptive Synergy + Rescue Mode)
+# (V36.0 - GEM-Architect: Regime-Adaptive Vision Full)
 # ============================================================
 
 import asyncio
@@ -9,32 +9,30 @@ import traceback
 import logging
 import pandas as pd
 import numpy as np
+import pandas_ta as ta
 from typing import List, Dict, Any
 
-# ✅ استيراد إعدادات النظام المركزية (للربط مع Processor)
+import ccxt.async_support as ccxt
+
+# ✅ استيراد الدستور الديناميكي (لقراءة الحالة الحالية)
 try:
     from ml_engine.processor import SystemLimits
 except ImportError:
-    # قيم افتراضية في حال فشل الاستيراد لتجنب توقف النظام
+    # Fallback إذا لم يتم التحميل بعد
     class SystemLimits:
-        L1_MIN_AFFINITY_SCORE = 10.0
+        L1_MIN_AFFINITY_SCORE = 15.0
+        CURRENT_REGIME = "RANGE"
 
-# ✅ استيراد مكتبة التداول
-import ccxt.async_support as ccxt
-
-# ============================================================
-# 📝 إعدادات التسجيل (Logging Configuration)
-# ============================================================
+# إعدادات التسجيل لإسكات الإزعاج
 logging.getLogger("httpx").setLevel(logging.WARNING)
 logging.getLogger("httpcore").setLevel(logging.WARNING)
 logging.getLogger("ccxt").setLevel(logging.WARNING)
 
 class DataManager:
     """
-    DataManager V18.3 (Adaptive)
-    ----------------------------
-    المسؤول عن جلب البيانات من المنصة، فلترتها، وتجهيزها للمعالج.
-    يتميز بنظام 'Synergy Matrix' المرن الذي يتكيف مع ظروف السوق (Rescue Mode).
+    DataManager V36.0 (The Chameleon Eye)
+    - تتغير خوارزمية الفلترة (L1) تماماً بناءً على حالة السوق (Regime).
+    - تعتمد على SystemLimits.CURRENT_REGIME لتحديد التكتيك.
     """
 
     def __init__(self, contracts_db, whale_monitor, r2_service=None):
@@ -61,16 +59,15 @@ class DataManager:
             'UP', 'DOWN', 'BEAR', 'BULL', '3S', '3L', 'USDD', 'USDP'
         ]
         
-        print(f"📦 [DataManager] Instance Created. Blacklist items: {len(self.BLACKLIST_TOKENS)}")
+        print(f"📦 [DataManager V36.0] Adaptive Vision Online.")
 
     async def initialize(self):
         """تهيئة مدير البيانات والاتصالات"""
         print("   > [DataManager] Starting initialization...")
         try:
-            # ✅ GEM-Architect: زيادة الـ Timeout لتجنب مشاكل الشبكة أثناء الضغط
             self.http_client = httpx.AsyncClient(timeout=60.0)
             await self._load_markets()
-            print(f"✅ [DataManager V18.3] Ready (Mode: Synergy Matrix | Adaptive 100).")
+            print(f"✅ [DataManager] Ready (Mode: {getattr(SystemLimits, 'CURRENT_REGIME', 'UNKNOWN')}).")
         except Exception as e:
             print(f"❌ [DataManager] Init Error: {e}")
             traceback.print_exc()
@@ -83,7 +80,6 @@ class DataManager:
                 if not self.exchange.markets:
                     await self.exchange.load_markets()
                 self.market_cache = self.exchange.markets
-                # print(f"   -> [DataManager] Markets loaded: {len(self.market_cache)} pairs.")
         except Exception as e:
             print(f"❌ [DataManager] Market load failed: {e}")
             traceback.print_exc()
@@ -97,10 +93,9 @@ class DataManager:
         print("🛑 [DataManager] Connections Closed.")
 
     # ==================================================================
-    # 🚀 R2 Compatibility (Integration Methods)
+    # 🚀 R2 Compatibility
     # ==================================================================
     async def load_contracts_from_r2(self):
-        """تحميل قاعدة بيانات العقود من خدمة R2"""
         if not self.r2_service: return
         try:
             self.contracts_db = await self.r2_service.load_contracts_db_async()
@@ -110,132 +105,102 @@ class DataManager:
             self.contracts_db = {}
 
     def get_contracts_db(self) -> Dict[str, Any]:
-        """إرجاع قاعدة البيانات الحالية"""
         return self.contracts_db
-    
+
     # ==================================================================
-    # 🛡️ Layer 1: Synergy Screening (GEM-Architect Fix: Adaptive & Debuggable)
+    # 🛡️ Layer 1: Regime-Adaptive Screening (The Core Update)
     # ==================================================================
     async def layer1_rapid_screening(self) -> List[Dict[str, Any]]:
         """
-        الفلترة الذكية (نسخة مصححة): تتكيف مع ظروف السوق وتعالج مشاكل البيانات.
-        تقوم بمسح أفضل 100 عملة وتفعيل وضع الإنقاذ إذا كانت النتائج صفرية.
+        تقوم باختيار استراتيجية المسح بناءً على حالة السوق الحالية.
         """
-        print(f"🔍 [Layer 1] Initiating Synergy Matrix Screening...")
+        # 1. تحديد الحالة من الدستور
+        # ملاحظة: AdaptiveHub هو المسؤول عن تحديث هذه القيمة في SystemLimits
+        current_regime = getattr(SystemLimits, "CURRENT_REGIME", "RANGE")
+        min_score = getattr(SystemLimits, "L1_MIN_AFFINITY_SCORE", 15.0)
         
-        # 1. المرحلة 0: فلتر الكون (استبعاد العملات الميتة)
-        initial_candidates = await self._stage0_universe_filter()
+        print(f"🔍 [Layer 1] Screening Mode: {current_regime} | Min Score: {min_score}")
         
-        if not initial_candidates:
-            print("⚠️ [Layer 1] No candidates passed Stage 0 (Check Internet/API).")
+        # 2. جلب الكون الأولي (Universe) - استخدام الفلتر الأساسي الكامل
+        all_tickers = await self._stage0_universe_filter()
+        if not all_tickers: 
+            print("⚠️ [Layer 1] No tickers passed Stage 0.")
             return []
 
-        # ✅ GEM-Architect Update: فحص أفضل 100 عملة حسب الطلب
-        # تم تحديد العدد لضمان التوازن بين كفاءة المسح وتجنب الحظر
-        top_liquid_candidates = initial_candidates[:100] 
+        # 3. توجيه المسح حسب الاستراتيجية
+        candidates = []
         
-        print(f"   -> Fetching deep data for top {len(top_liquid_candidates)} assets...")
-        enriched_data = await self._fetch_technical_and_depth_batch(top_liquid_candidates)
+        if current_regime == "BULL":
+            candidates = self._pre_filter_bull(all_tickers)
+        elif current_regime == "BEAR":
+            candidates = self._pre_filter_bear(all_tickers)
+        elif current_regime == "DEAD":
+            candidates = self._pre_filter_dead(all_tickers)
+        else: # RANGE or Default
+            candidates = self._pre_filter_range(all_tickers)
+            
+        print(f"   -> Pre-filter selected {len(candidates)} candidates for Deep Scan.")
         
-        # 🚨 Debug Check: هل البيانات تصل فعلاً؟
-        if len(enriched_data) == 0:
-            print("❌ [CRITICAL] 0 assets returned data. API might be throttling or returning empty responses.")
-            return []
+        # 4. الجلب العميق للبيانات (Deep Data Fetch)
+        # نأخذ أفضل 60 عملة فقط لتوفير الموارد
+        top_candidates = candidates[:60]
+        enriched_data = await self._fetch_technical_and_depth_batch(top_candidates)
         
-        # 3. حساب النقاط (Synergy Score)
-        scored_candidates = []
-        debug_scores = [] # لتسجيل وتتبع لماذا تفشل العملات
+        if not enriched_data:
+            print("❌ [Layer 1] Failed to fetch deep data.")
+            return []
 
-        # ✅ استخدام حد أدنى مرن (Adaptive Threshold)
-        current_threshold = SystemLimits.L1_MIN_AFFINITY_SCORE 
-        
+        # 5. حساب النقاط (Synergy Score) بناءً على الحالة
+        final_selection = []
         for item in enriched_data:
-            # استدعاء دالة التقييم الجديدة
-            affinity_result = self._calculate_synergy_score(item)
-            score = affinity_result['score']
-            item['l1_score'] = score
-            item['tags'] = affinity_result['tags']
-            
-            debug_scores.append(score)
-            
-            # إذا حققت الحد الأدنى من النقاط، نضيفها للقائمة
-            if score >= current_threshold: 
-                scored_candidates.append(item)
-
-        # 4. 🔥 نظام الإنقاذ (Rescue Mode)
-        # إذا لم نجد أي عملة بالفلتر القاسي، نخفض المعايير فوراً بدلاً من إرجاع قائمة فارغة
-        if len(scored_candidates) == 0 and len(enriched_data) > 0:
-            max_found_score = max(debug_scores) if debug_scores else 0
-            print(f"⚠️ [Layer 1] Too strict! Max score found was {max_found_score:.2f}. Activating Rescue Mode...")
-            
-            # إعادة المحاولة بحد أدنى 0 (أي عملة إيجابية تقنياً)
-            for item in enriched_data:
-                if item['l1_score'] > 0:
-                    scored_candidates.append(item)
+            synergy = self._calculate_adaptive_score(item, current_regime)
+            item['l1_score'] = synergy['score']
+            item['tags'] = synergy['tags']
             
-            if scored_candidates:
-                print(f"   -> ✅ Rescue Mode found {len(scored_candidates)} candidates with Score > 0.")
+            if item['l1_score'] >= min_score:
+                final_selection.append(item)
 
-        # 5. الترتيب واختيار النخبة
-        # ترتيب تنازلي حسب النقاط
-        scored_candidates.sort(key=lambda x: x['l1_score'], reverse=True)
-
-        # ✅ طباعة النتائج للمراقبة
-        if len(scored_candidates) > 0:
-            print("-" * 75)
-            print(f"{'SYMBOL':<12} | {'SCORE':<6} | {'TAGS'}")
-            print("-" * 75)
-            for item in scored_candidates[:5]: # طباعة أفضل 5 فقط لعدم إغراق السجل
-                tags_str = ", ".join(item.get('tags', []))
-                print(f"{item['symbol']:<12} | {item['l1_score']:<6.1f} | {tags_str}")
-            print("-" * 75)
+        # ترتيب نهائي وتنظيف
+        final_selection.sort(key=lambda x: x['l1_score'], reverse=True)
+        
+        # طباعة عينة للمراقبة
+        if final_selection:
+            print(f"   -> Top pick: {final_selection[0]['symbol']} (Score: {final_selection[0]['l1_score']:.1f})")
         else:
-             print(f"❌ [Layer 1] Still 0 candidates after Rescue Mode. Market is extremely weird or Data is bad.")
-
-        # نختار أفضل 40 عملة فقط لتمريرها للمعالجة العميقة (L2/L3)
-        final_selection = scored_candidates[:40]
+            print("⚠️ [Layer 1] No candidates passed the adaptive score threshold.")
         
-        # تنظيف البيانات لتمرير ما يهم المعالج فقط
-        cleaned_selection = []
-        for item in final_selection:
-            cleaned_selection.append({
-                'symbol': item['symbol'],
-                'quote_volume': item.get('quote_volume', 0),
-                'current_price': item.get('current_price', 0),
-                'type': ','.join(item.get('tags', [])), # تمرير التاغات كسترينغ
-                'l1_score': item.get('l1_score', 0)
-            })
-
-        print(f"✅ [Layer 1] Passed {len(cleaned_selection)} Synergy assets to Processor.")
-        return cleaned_selection
+        # نمرر أفضل 40 للمعالج
+        return [
+            {
+                'symbol': c['symbol'],
+                'quote_volume': c.get('quote_volume', 0),
+                'current_price': c.get('current_price', 0),
+                'type': ','.join(c.get('tags', [])),
+                'l1_score': c.get('l1_score', 0)
+            }
+            for c in final_selection[:40] 
+        ]
 
-    # ------------------------------------------------------------------
-    # Stage 0: Universe Filter (Basic Liquidity Check)
-    # ------------------------------------------------------------------
+    # ==================================================================
+    # 🌍 Stage 0 & Pre-Filters
+    # ==================================================================
     async def _stage0_universe_filter(self) -> List[Dict[str, Any]]:
         """
-        فلتر أولي سريع جداً لاستبعاد:
-        - العملات ذات السيولة المعدومة (أقل من 300 ألف دولار).
-        - العملات المستقرة والمحظورة.
-        - العملات ذات السعر الصفري تقريباً (أخطاء بيانات).
+        فلتر أولي سريع لاستبعاد العملات الميتة أو المحظورة.
         """
         try:
             tickers = await self.exchange.fetch_tickers()
             candidates = []
             
             for symbol, ticker in tickers.items():
-                # نقبل فقط أزواج USDT
                 if not symbol.endswith('/USDT'): continue
                 
-                # التحقق من القائمة السوداء
                 base_curr = symbol.split('/')[0]
                 if any(bad in base_curr for bad in self.BLACKLIST_TOKENS): continue
                 
-                # شرط السيولة (Quote Volume)
                 quote_vol = ticker.get('quoteVolume')
                 if not quote_vol or quote_vol < 300_000: continue # Min 300k USDT
                 
-                # شرط السعر المنطقي
                 last_price = ticker.get('last')
                 if not last_price or last_price < 0.0001: continue 
 
@@ -243,41 +208,118 @@ class DataManager:
                     'symbol': symbol,
                     'quote_volume': quote_vol,
                     'current_price': last_price,
-                    'change_24h': ticker.get('percentage', 0.0) 
+                    'change_24h': float(ticker.get('percentage', 0.0)) 
                 })
             
-            # الترتيب حسب السيولة لضمان أننا نفحص الأقوى أولاً
-            candidates.sort(key=lambda x: x['quote_volume'], reverse=True)
             return candidates
-            
         except Exception as e:
             print(f"❌ [L1 Error] Universe filter failed: {e}")
             return []
 
-    # ------------------------------------------------------------------
-    # Data Fetching Helpers (Updated for Depth & Parallel Execution)
-    # ------------------------------------------------------------------
-    async def _fetch_technical_and_depth_batch(self, candidates: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def _pre_filter_bull(self, tickers):
+        """🐂 Bull Mode: السيولة العالية والارتفاع في السعر"""
+        filtered = [t for t in tickers if t['change_24h'] > -2.0 and t['quote_volume'] > 500_000]
+        filtered.sort(key=lambda x: (x['change_24h'], x['quote_volume']), reverse=True)
+        return filtered
+
+    def _pre_filter_bear(self, tickers):
+        """🐻 Bear Mode: الارتدادات من القاع (Panic Selling)"""
+        filtered = [t for t in tickers if t['change_24h'] < -5.0 and t['quote_volume'] > 1_000_000]
+        filtered.sort(key=lambda x: x['change_24h'], reverse=False) # تصاعدي (الأكثر سلبية)
+        return filtered
+
+    def _pre_filter_range(self, tickers):
+        """↔️ Range Mode: الاستقرار والسيولة المتوسطة"""
+        filtered = [t for t in tickers if -5.0 < t['change_24h'] < 5.0 and t['quote_volume'] > 300_000]
+        filtered.sort(key=lambda x: x['quote_volume'], reverse=True)
+        return filtered
+        
+    def _pre_filter_dead(self, tickers):
+        """💤 Dead/Accumulation Mode: سيولة منخفضة وتحرك مفاجئ"""
+        filtered = [t for t in tickers if t['quote_volume'] > 100_000]
+        import random
+        random.shuffle(filtered) # عشوائية لاستكشاف الجواهر
+        return filtered
+
+    # ==================================================================
+    # 🧠 Adaptive Scoring Matrix
+    # ==================================================================
+    def _calculate_adaptive_score(self, item: Dict[str, Any], regime: str) -> Dict[str, Any]:
         """
-        جلب البيانات الفنية (OHLCV) + دفتر الطلبات (Order Book) بالتوازي.
-        يتم تقسيم العملات إلى دفعات (Chunks) لتجنب الحظر.
+        حساب النقاط بناءً على السياق (Regime-Specific Scoring).
         """
-        chunk_size = 10 # عدد العملات في كل دفعة
+        try:
+            df = pd.DataFrame(item['ohlcv_1h'], columns=['ts', 'o', 'h', 'l', 'c', 'v'])
+            df['c'] = df['c'].astype(float)
+            
+            # المؤشرات الأساسية
+            curr_close = df['c'].iloc[-1]
+            rsi = ta.rsi(df['c'], 14).iloc[-1]
+            ema50 = ta.ema(df['c'], 50).iloc[-1]
+            
+            score = 0.0
+            tags = []
+
+            # 🐂 BULL LOGIC
+            if regime == "BULL":
+                # نحب الـ RSI العالي (زخم) لكن ليس المفرط جداً
+                if 55 < rsi < 80: score += 20
+                if curr_close > ema50: score += 20
+                tags.append("TrendFollow")
+            
+            # 🐻 BEAR LOGIC
+            elif regime == "BEAR":
+                # نحب الـ RSI المنخفض (تشبع بيعي)
+                if rsi < 30: 
+                    score += 30
+                    tags.append("Oversold")
+                elif rsi > 60: 
+                    score -= 20 # خطر
+                
+                # في السوق الهابط، السعر غالباً تحت EMA، نبحث عن الابتعاد الشديد عنه
+                dist = (curr_close - ema50) / ema50
+                if dist < -0.15: 
+                    score += 15
+                    tags.append("DeepValue")
+
+            # ↔️ RANGE LOGIC
+            elif regime == "RANGE":
+                # نحب الـ RSI في المنتصف للارتداد
+                if rsi < 35: 
+                    score += 25; tags.append("RangeBot")
+                elif rsi > 65: 
+                    score -= 10; tags.append("RangeTop")
+                else:
+                    score += 10 # منطقة آمنة
+            
+            # دفتر الطلبات (مشترك لكن بأوزان مختلفة ضمنياً)
+            ob = item.get('order_book_snapshot', {})
+            if ob:
+                bids = sum([float(x[1]) for x in ob.get('bids', [])[:10]])
+                asks = sum([float(x[1]) for x in ob.get('asks', [])[:10]])
+                if asks > 0:
+                    ratio = bids / asks
+                    if ratio > 1.5: score += 15; tags.append("BidWall")
+                    if regime == "BEAR" and ratio > 2.0: score += 20 # جدار الشراء في الهبوط إشارة قوية
+
+            return {'score': score, 'tags': tags}
+
+        except Exception:
+            return {'score': 0, 'tags': ['Error']}
+
+    # ==================================================================
+    # ⚡ Batch Fetching Utilities (Parallel Execution)
+    # ==================================================================
+    async def _fetch_technical_and_depth_batch(self, candidates: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """جلب البيانات الفنية + دفتر الطلبات بالتوازي"""
+        chunk_size = 10 
         results = []
         
         for i in range(0, len(candidates), chunk_size):
             chunk = candidates[i:i + chunk_size]
-            
-            # إنشاء مهام غير متزامنة لكل عملة في الدفعة
             chunk_tasks = [self._fetch_single_full_data(c) for c in chunk]
-            
-            # تنفيذ المهام وانتظار النتائج
             chunk_results = await asyncio.gather(*chunk_tasks)
-            
-            # تجميع النتائج الصالحة فقط
             results.extend([r for r in chunk_results if r is not None])
-            
-            # استراحة قصيرة جداً لتخفيف الحمل على الذاكرة والشبكة
             await asyncio.sleep(0.1) 
             
         return results
@@ -286,159 +328,41 @@ class DataManager:
         """جلب بيانات عملة واحدة (شارت + عمق)"""
         symbol = candidate['symbol']
         try:
-            # 1. طلب الشموع (OHLCV) - نحتاج 200 شمعة لحساب المتوسطات الطويلة (EMA 200)
-            ohlcv_task = self.exchange.fetch_ohlcv(symbol, '1h', limit=205)
-            
-            # 2. طلب دفتر الطلبات (Order Book) - لقطة لأفضل 20 مستوى فقط
+            ohlcv_task = self.exchange.fetch_ohlcv(symbol, '1h', limit=100)
             ob_task = self.exchange.fetch_order_book(symbol, limit=20)
             
-            # تنفيذ الطلبين معاً
             ohlcv_1h, order_book = await asyncio.gather(ohlcv_task, ob_task)
             
-            # التحقق من جودة البيانات
-            if not ohlcv_1h or len(ohlcv_1h) < 200:
-                return None # بيانات غير كافية للتحليل
+            if not ohlcv_1h or len(ohlcv_1h) < 50:
+                return None 
                 
             candidate['ohlcv_1h'] = ohlcv_1h
             candidate['order_book_snapshot'] = order_book
             return candidate
             
         except Exception:
-            # في حال فشل الجلب (Timeout أو غيره)، نتجاهل العملة
             return None
 
-    # ------------------------------------------------------------------
-    # 🧠 The Logic Core: Synergy Matrix Scoring (New V18.2 Logic)
-    # ------------------------------------------------------------------
-    def _calculate_synergy_score(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        مصفوفة التوافق (Synergy Matrix):
-        تقوم بحساب النقاط بناءً على العلاقات المترابطة بين المؤشرات.
-        لا تعتمد على القيم المطلقة فقط، بل على سياق السوق.
-        """
-        try:
-            # تحويل البيانات إلى DataFrame للتحليل
-            df = pd.DataFrame(data['ohlcv_1h'], columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
-            ob = data.get('order_book_snapshot', {})
-            
-            df['close'] = df['close'].astype(float)
-            df['volume'] = df['volume'].astype(float)
-            
-            # --- 1. حساب المؤشرات الفنية الأساسية ---
-            
-            # EMA (العمود الفقري للاتجاه)
-            df['ema50'] = df['close'].ewm(span=50, adjust=False).mean()
-            df['ema200'] = df['close'].ewm(span=200, adjust=False).mean()
-            
-            # RSI (مؤشر الزخم)
-            delta = df['close'].diff()
-            gain = (delta.where(delta > 0, 0)).rolling(14).mean()
-            loss = (-delta.where(delta < 0, 0)).rolling(14).mean()
-            rs = gain / loss
-            df['rsi'] = 100 - (100 / (1 + rs))
-            
-            # Volume MA (متوسط الحجم)
-            df['vol_ma'] = df['volume'].rolling(20).mean()
-            
-            curr = df.iloc[-1]
-            score = 0.0
-            tags = []
-
-            # --- 2. تحليل دفتر الطلبات (Macro Order Book) ---
-            # حساب نسبة ضغط الشراء مقابل البيع (Bid/Ask Ratio)
-            depth_ratio = 1.0
-            total_bids = 0
-            if ob and 'bids' in ob and 'asks' in ob:
-                total_bids = sum([b[1] for b in ob['bids']])
-                total_asks = sum([a[1] for a in ob['asks']])
-                if total_asks > 0: 
-                    depth_ratio = total_bids / total_asks
-
-            # --- 3. مصفوفة العلاقات (Logic Execution) ---
-            
-            close = curr['close']
-            ema50 = curr['ema50']
-            ema200 = curr['ema200']
-            rsi = curr['rsi']
-            
-            # الحالة A: الثور المؤكد (Confirmed Trend)
-            # السعر فوق المتوسطات + يوجد دعم حقيقي في الدفتر
-            if close > ema50 and close > ema200:
-                base_trend = 20
-                if depth_ratio > 1.1: # توافق إيجابي
-                    score += (base_trend * 1.5) 
-                    tags.append("ConfirmedTrend")
-                elif depth_ratio < 0.8: # تناقض (سعر صاعد لكن الحيتان يبيعون)
-                    score -= 20 
-                    tags.append("BullTrap⚠️")
-                else:
-                    score += base_trend # اتجاه صاعد عادي
-
-            # الحالة B: صيد الحيتان / الارتداد (Whale Net)
-            # السعر تحت المتوسطات (هابط) لكن الدفتر يظهر شراء عنيف
-            elif close < ema50:
-                if depth_ratio > 1.5 and rsi < 35: # شراء قوي جداً عند القاع
-                    score += 40 # نغفر سلبية المتوسط بسبب قوة الدفتر
-                    tags.append("WhaleNet🔥")
-                elif depth_ratio > 1.2:
-                    score += 15
-                    tags.append("SupprortBuild")
-                else:
-                    score -= 30 # هبوط بدون دعم = انهيار
-
-            # الحالة C: الزخم والحجم (Momentum & Volume)
-            # حساب الحجم النسبي (Relative Volume)
-            rvol = curr['volume'] / curr['vol_ma'] if curr['vol_ma'] > 0 else 1.0
-            
-            if rsi > 50 and rsi < 75:
-                if rvol > 1.2: # زخم سعري مع سيولة
-                    score += 15
-                    tags.append("MomVol")
-                else:
-                    score += 5 
-
-            # حالة خاصة: الامتداد السعري المفرط (Over Extension)
-            # السعر ابتعد كثيراً عن المتوسط (خطر التصحيح)
-            dist_from_ema = (close - ema50) / ema50
-            if dist_from_ema > 0.20: # 20% فوق المتوسط
-                score -= 10 
-                tags.append("OverExtended")
-            
-            # إرجاع النتيجة
-            return {
-                'is_eligible': score > SystemLimits.L1_MIN_AFFINITY_SCORE,
-                'score': score,
-                'tags': tags
-            }
-
-        except Exception as e:
-            # في حال حدوث خطأ حسابي، نرفض العملة للأمان
-            return {'is_eligible': False, 'score': 0, 'tags': []}
-
     # ==================================================================
-    # 🎯 Public Helpers (Legacy & Utility Methods)
+    # 🎯 Public Helpers
     # ==================================================================
     async def get_latest_price_async(self, symbol: str) -> float:
-        """جلب آخر سعر للعملة"""
         try:
             ticker = await self.exchange.fetch_ticker(symbol)
             return float(ticker['last'])
         except Exception: return 0.0
 
     async def get_latest_ohlcv(self, symbol: str, timeframe: str = '5m', limit: int = 100) -> List[List[float]]:
-        """جلب بيانات الشموع (OHLCV)"""
         try:
             candles = await self.exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
             return candles or []
         except Exception: return []
 
     async def get_order_book_snapshot(self, symbol: str, limit: int = 20) -> Dict[str, Any]:
-        """جلب لقطة سريعة لدفتر الطلبات"""
         try:
             ob = await self.exchange.fetch_order_book(symbol, limit)
             return ob
         except Exception: return {}
 
     def get_supported_timeframes(self):
-        """إرجاع الإطارات الزمنية المدعومة"""
         return list(self.exchange.timeframes.keys()) if self.exchange else []