Update whale_news_data.py

whale_news_data.py

@@ -8,10 +8,20 @@ from datetime import datetime, timedelta
 from collections import defaultdict, deque
 import ccxt.pro as ccxt
 import numpy as np
+import logging
+
+# تعطيل تسجيل HTTP المزعج
+logging.getLogger("httpx").setLevel(logging.WARNING)
+logging.getLogger("httpcore").setLevel(logging.WARNING)
 
 class EnhancedWhaleMonitor:
     def __init__(self, contracts_db=None, r2_service=None):
-        self.http_client = httpx.AsyncClient(timeout=15.0, limits=httpx.Limits(max_connections=50, max_keepalive_connections=10))
+        # تعطيل التسجيل التفصيلي لـ HTTP Client
+        self.http_client = httpx.AsyncClient(
+            timeout=15.0, 
+            limits=httpx.Limits(max_connections=50, max_keepalive_connections=10),
+            follow_redirects=True
+        )
         
         self.moralis_key = os.getenv("MORALIS_KEY")
         self.etherscan_key = os.getenv("ETHERSCAN_KEY")
@@ -99,8 +109,8 @@ class EnhancedWhaleMonitor:
         self.price_cache = {}
         self.last_scan_time = {}
         
-        self.contract_cache = {}  # كاش جديد للعقود
-        self.symbol_networks = {}  # تتبع الشبكات المناسبة للرموز
+        self.contract_cache = {}
+        self.symbol_networks = {}
         
         self.pattern_performance = {}
         self.pattern_success_rates = {}
@@ -108,7 +118,6 @@ class EnhancedWhaleMonitor:
         if self.r2_service:
             asyncio.create_task(self._load_pattern_performance())
             
-        # تحميل العقود من R2 إذا كان متوفراً
         if self.r2_service:
             asyncio.create_task(self._load_contracts_from_r2())
 
@@ -159,7 +168,6 @@ class EnhancedWhaleMonitor:
             response = self.r2_service.s3_client.get_object(Bucket="trading", Key=key)
             contracts_data = json.loads(response['Body'].read())
             
-            # تحديث قاعدة البيانات المحلية
             self.contracts_db.update(contracts_data)
             print(f"✅ تم تحميل {len(contracts_data)} عقد من R2")
             
@@ -195,7 +203,6 @@ class EnhancedWhaleMonitor:
 
     async def _load_pattern_performance(self):
         if not self.r2_service:
-            print("⚠️ R2 Service غير متوفر لتحميل بيانات الأنماط")
             return
             
         try:
@@ -204,15 +211,12 @@ class EnhancedWhaleMonitor:
             data = json.loads(response['Body'].read())
             self.pattern_performance = data.get('pattern_performance', {})
             self.pattern_success_rates = data.get('pattern_success_rates', {})
-            print(f"✅ تم تحميل بيانات أداء الأنماط: {len(self.pattern_performance)} نمط")
         except Exception as e:
-            print(f"⚠️ لم يتم العثور على بيانات أداء الأنماط: {e}")
             self.pattern_performance = {}
             self.pattern_success_rates = {}
 
     async def _save_pattern_performance(self):
         if not self.r2_service:
-            print("⚠️ R2 Service غير متوفر لحفظ بيانات الأنماط")
             return
             
         try:
@@ -228,7 +232,6 @@ class EnhancedWhaleMonitor:
             self.r2_service.s3_client.put_object(
                 Bucket="trading", Key=key, Body=data_json, ContentType="application/json"
             )
-            print(f"✅ تم حفظ بيانات أداء الأنماط: {len(self.pattern_performance)} نمط")
         except Exception as e:
             print(f"❌ فشل حفظ بيانات أداء الأنماط: {e}")
 
@@ -262,7 +265,6 @@ class EnhancedWhaleMonitor:
             self.address_categories['unknown'].add(address_lower)
             return 'unknown'
         except Exception as e:
-            print(f"❌ خطأ في تصنيف العنوان: {e}")
             return 'unknown'
 
     def _detect_exchange_pattern(self, transactions):
@@ -300,7 +302,6 @@ class EnhancedWhaleMonitor:
                     address_lower in self.address_categories['exchange'] or
                     self.address_labels.get(address_lower) in ['cex', 'suspected_cex'])
         except Exception as e:
-            print(f"❌ خطأ في التحقق من عنوان التبادل: {e}")
             return False
 
     async def _update_netflow_metrics(self, network, token_symbol, from_address, to_address, value_usd, transaction_hash):
@@ -330,7 +331,7 @@ class EnhancedWhaleMonitor:
                 self.netflow_data[network][token_symbol]['netflow'].append(current_netflow)
                 
         except Exception as e:
-            print(f"❌ خطأ في تحديث مقاييس صافي التدفق: {e}")
+            pass
 
     def _initialize_token_metrics(self, network, token_symbol):
         self.netflow_data[network][token_symbol] = {
@@ -370,7 +371,6 @@ class EnhancedWhaleMonitor:
             return zscore
             
         except Exception as e:
-            print(f"❌ خطأ في حساب Z-score: {e}")
             return 0
 
     def _generate_netflow_signal(self, network, token_symbol):
@@ -445,7 +445,6 @@ class EnhancedWhaleMonitor:
             return signal
             
         except Exception as e:
-            print(f"❌ خطأ في توليد إشارة التداول: {e}")
             return None
 
     async def _scan_single_evm_network(self, network):
@@ -454,17 +453,14 @@ class EnhancedWhaleMonitor:
         
         try:
             if not self.data_manager:
-                print(f"⚠️ DataManager غير متوفر لمسح شبكة {network}")
                 return [], []
                 
             price_usd = await self.data_manager.get_native_coin_price(network)
             if price_usd is None:
-                print(f"⚠️ لم يتم الحصول على سعر لـ {network}")
                 return [], []
 
             latest_block_hex = await self._call_rpc_async(network, 'eth_blockNumber')
             if not latest_block_hex: 
-                print(f"⚠️ فشل الحصول على أحدث كتلة لـ {network}")
                 return [], []
             
             latest_block = int(latest_block_hex, 16)
@@ -522,23 +518,19 @@ class EnhancedWhaleMonitor:
                             })
                             whale_transactions_found += 1
                             
-                if block_offset % 3 == 0:
-                    await asyncio.sleep(0.1)
+                await asyncio.sleep(0.05)
                     
             signal = self._generate_netflow_signal(network, 'NATIVE')
             if signal:
                 trading_signals.append(signal)
 
-            print(f"✅ تم مسح {scanned_blocks} كتلة في {network} - تم العثور على {whale_transactions_found} معاملة حوت")
             return whale_alerts, trading_signals
                     
         except Exception as e:
-            print(f"❌ خطأ في مسح شبكة {network}: {e}")
             return [], []
 
     async def get_general_whale_activity(self):
         try:
-            print("🔍 بدء مسح نشاط الحيتان العام...")
             tasks = []
             networks_to_scan = ['ethereum', 'bsc']
             for network in networks_to_scan:
@@ -556,9 +548,8 @@ class EnhancedWhaleMonitor:
                     all_alerts.extend(alerts)
                     all_signals.extend(signals)
                     successful_networks += 1
-                    print(f"✅ شبكة {networks_to_scan[i]} تمت معالجتها بنجاح")
                 else:
-                    print(f"❌ فشل معالجة شبكة {networks_to_scan[i]}: {res}")
+                    pass
 
             all_alerts.sort(key=lambda x: x['timestamp'], reverse=True)
             
@@ -591,13 +582,11 @@ class EnhancedWhaleMonitor:
                         'flow_direction': 'BALANCED'
                     }
                 }
-                print("ℹ️ لم يتم اكتشاف أي نشاط حيتان كبير")
                 return result
             
             latest_alert = all_alerts[0] if all_alerts else None
             latest_time_info = f"آخر نشاط منذ {latest_alert['minutes_ago']:.1f} دقيقة" if latest_alert else ""
             
-            # تحديد flow_direction بشكل آمن
             flow_direction = 'BALANCED'
             if net_exchange_flow < 0:
                 flow_direction = 'TO_EXCHANGES'
@@ -668,8 +657,6 @@ class EnhancedWhaleMonitor:
             
         except Exception as e:
             print(f"❌ فشل مراقبة الحيتان العامة: {e}")
-            import traceback
-            traceback.print_exc()
             return {
                 'data_available': False,
                 'description': f'غير متوفر - فشل في مراقبة الحيتان: {str(e)}',
@@ -683,12 +670,11 @@ class EnhancedWhaleMonitor:
             }
 
     async def _call_rpc_async(self, network, method, params=[]):
-        max_retries = 3
+        max_retries = 2
         
         for attempt in range(max_retries):
             endpoint = self._get_next_rpc_endpoint(network)
             if not endpoint:
-                print(f"❌ لا توجد نقاط نهاية متاحة لـ {network}")
                 return None
                 
             try:
@@ -700,18 +686,16 @@ class EnhancedWhaleMonitor:
                 
                 payload = {"jsonrpc": "2.0", "method": method, "params": params, "id": 1}
                 
-                timeout = 25.0 if method == 'eth_getBlockByNumber' else 12.0
+                timeout = 20.0
                 
                 async with httpx.AsyncClient(timeout=timeout) as client:
                     response = await client.post(endpoint, json=payload)
                     
                     if response.status_code == 401:
-                        print(f"❌ خطأ في المصادقة لنقطة النهاية {endpoint}")
                         self._remove_rpc_endpoint(network, endpoint)
                         continue
                     elif response.status_code == 429:
-                        print(f"⏰ تجاوز حد المعدل لنقطة النهاية {endpoint}")
-                        await asyncio.sleep(2 * (attempt + 1))
+                        await asyncio.sleep(1 * (attempt + 1))
                         continue
                         
                     response.raise_for_status()
@@ -720,27 +704,12 @@ class EnhancedWhaleMonitor:
                     self.rpc_failures[network] = 0
                     return result
                     
-            except httpx.HTTPStatusError as e:
-                if e.response.status_code == 429:
-                    self.rpc_failures[network] += 1
-                    await asyncio.sleep(3 * (attempt + 1))
-                    continue
-                elif e.response.status_code == 401:
-                    self.rpc_failures[network] += 1
-                    self._remove_rpc_endpoint(network, endpoint)
-                    continue
-                else:
-                    self.rpc_failures[network] += 1
-                    print(f"❌ خطأ HTTP في RPC {network}: {e}")
-                    
             except Exception as e:
                 self.rpc_failures[network] += 1
-                print(f"❌ خطأ عام في RPC {network}: {e}")
                 
             if attempt < max_retries - 1:
-                await asyncio.sleep(1 * (attempt + 1))
+                await asyncio.sleep(0.5)
         
-        print(f"❌ فشل جميع محاولات RPC لـ {network}")
         return None
 
     def _get_next_rpc_endpoint(self, network):
@@ -760,7 +729,6 @@ class EnhancedWhaleMonitor:
     def _remove_rpc_endpoint(self, network, endpoint):
         if network in self.rpc_endpoints and endpoint in self.rpc_endpoints[network]:
             self.rpc_endpoints[network].remove(endpoint)
-            print(f"⚠️ تمت إزالة نقطة RPC {endpoint} من {network} بسبب الفشل")
             
             if self.current_rpc_index[network] >= len(self.rpc_endpoints[network]):
                 self.current_rpc_index[network] = 0
@@ -803,68 +771,53 @@ class EnhancedWhaleMonitor:
         if api_name == 'etherscan':
             if stats['requests_per_second'] > 4:
                 delay = 0.2 * (stats['requests_per_second'] - 4)
-                print(f"⏰ تأخير {delay:.2f} ثانية لتجنب حد المعدل لـ {api_name}")
                 await asyncio.sleep(delay)
             
             if stats['requests_today'] > 95000:
-                print(f"🚨 تجاوز الحد اليومي لـ {api_name}")
                 return True
         
         elif api_name == 'infura':
             if stats['requests_per_second'] > 90:
                 delay = 0.1 * (stats['requests_per_second'] - 90)
-                print(f"⏰ تأخير {delay:.2f} ثانية لتجنب حد المعدل لـ {api_name}")
                 await asyncio.sleep(delay)
             
             if stats['requests_today'] > 99000:
-                print(f"🚨 تجاوز الحد اليومي لـ {api_name}")
                 return True
         
         elif api_name == 'moralis':
             if stats['requests_per_second'] > 4:
                 delay = 0.2 * (stats['requests_per_second'] - 4)
-                print(f"⏰ تأخير {delay:.2f} ثانية لتجنب حد المعدل لـ {api_name}")
                 await asyncio.sleep(delay)
             
             if stats['requests_today'] > 95000:
-                print(f"🚨 تجاوز الحد اليومي لـ {api_name}")
                 return True
         
         return False
 
     async def _find_contract_address_enhanced(self, symbol):
-        """بحث محسن عن عنوان العقد باستخدام مصادر متعددة"""
         base_symbol = symbol.split("/")[0] if '/' in symbol else symbol
         symbol_lower = base_symbol.lower()
         
-        # البحث في الكاش أولاً
         if symbol_lower in self.contract_cache:
             return self.contract_cache[symbol_lower]
         
-        # البحث في قاعدة البيانات المحلية
         for key, address in self.contracts_db.items():
             if symbol_lower in key.lower():
                 self.contract_cache[symbol_lower] = address
-                print(f"✅ تم العثور على عنوان العقد لـ {symbol} في قاعدة البيانات: {address}")
                 return address
         
-        # البحث عبر CoinGecko
         coingecko_address = await self._find_contract_via_coingecko(base_symbol)
         if coingecko_address:
             self.contract_cache[symbol_lower] = coingecko_address
-            # حفظ في قاعدة البيانات للمستقبل
             self.contracts_db[symbol_lower] = coingecko_address
             if self.r2_service:
                 await self._save_contracts_to_r2()
             return coingecko_address
         
-        print(f"⚠️ لم يتم العثور على عنوان عقد لـ {symbol} في أي مصدر")
         return None
 
     async def _find_contract_via_coingecko(self, symbol):
-        """البحث عن عنوان العقد عبر CoinGecko API"""
         try:
-            # البحث عن ID العملة أولاً
             search_url = f"https://api.coingecko.com/api/v3/search?query={symbol}"
             async with httpx.AsyncClient(timeout=15) as client:
                 response = await client.get(search_url)
@@ -877,31 +830,24 @@ class EnhancedWhaleMonitor:
                 if not coins:
                     return None
                 
-                # أخذ أفضل نتيجة مطابقة
                 best_coin = coins[0]
                 coin_id = best_coin.get('id')
                 
                 if not coin_id:
                     return None
                 
-                # جلب تفاصيل العملة
                 detail_url = f"https://api.coingecko.com/api/v3/coins/{coin_id}"
                 detail_response = await client.get(detail_url)
                 if detail_response.status_code != 200:
                     return None
                 
                 detail_data = detail_response.json()
-                
-                # البحث عن عناوين العقود في المنصات المختلفة
                 platforms = detail_data.get('platforms', {})
                 
-                # إعطاء الأولوية لـ Ethereum ثم BSC ثم Polygon
                 for platform in ['ethereum', 'binance-smart-chain', 'polygon-pos']:
                     if platform in platforms and platforms[platform]:
                         address = platforms[platform]
-                        if address and len(address) == 42:  # تأكيد أن العنوان صالح
-                            print(f"✅ تم العثور على عنوان {symbol} على {platform}: {address}")
-                            # تحديد الشبكة المناسبة للرمز
+                        if address and len(address) == 42:
                             network_map = {
                                 'ethereum': 'ethereum',
                                 'binance-smart-chain': 'bsc', 
@@ -913,51 +859,40 @@ class EnhancedWhaleMonitor:
                 return None
                 
         except Exception as e:
-            print(f"❌ فشل البحث عن عقد {symbol} عبر CoinGecko: {e}")
             return None
 
     async def _save_contracts_to_r2(self):
-        """حفظ قاعدة بيانات العقود إلى R2"""
         try:
             key = "contracts_database.json"
             data_json = json.dumps(self.contracts_db, indent=2).encode('utf-8')
             self.r2_service.s3_client.put_object(
                 Bucket="trading", Key=key, Body=data_json, ContentType="application/json"
             )
-            print(f"✅ تم حفظ {len(self.contracts_db)} عقد في R2")
         except Exception as e:
-            print(f"❌ فشل حفظ العقود في R2: {e}")
+            pass
 
     async def get_symbol_specific_whale_data(self, symbol, contract_address=None):
         try:
-            print(f"🔍 جلب بيانات الحيتان لـ {symbol}...")
             base_symbol = symbol.split("/")[0] if '/' in symbol else symbol
             
-            # البحث عن عنوان العقد إذا لم يتم توفيره
             if not contract_address:
                 contract_address = await self._find_contract_address_enhanced(base_symbol)
             
             if not contract_address:
-                print(f"⚠️ لم يتم العثور على عنوان عقد لـ {symbol}")
                 return await self._scan_networks_for_symbol(symbol, base_symbol)
             
-            # تحديد الشبكة المناسبة للبحث
             network = self.symbol_networks.get(base_symbol, 'ethereum')
-            print(f"🔍 البحث في شبكة {network} للرمز {symbol}")
             
             api_data = await self._get_combined_api_data(contract_address, network)
             
             if api_data:
                 enriched_data = await self._enrich_api_data_with_timing(api_data)
                 result = self._analyze_symbol_specific_data(enriched_data, symbol)
-                print(f"✅ تم تحليل بيانات الحيتان لـ {symbol}: {result.get('transfer_count', 0)} تحويل")
                 return result
             else:
-                print(f"⚠️ لا توجد بيانات API لـ {symbol}")
                 return await self._scan_networks_for_symbol(symbol, base_symbol)
                 
         except Exception as e:
-            print(f"❌ فشل جلب بيانات الحيتان لـ {symbol}: {e}")
             return {
                 'data_available': False,
                 'description': f'غير متوفر - خطأ في جلب بيانات الحيتان',
@@ -969,7 +904,6 @@ class EnhancedWhaleMonitor:
     async def _get_combined_api_data(self, contract_address, network='ethereum'):
         tasks = []
         
-        # ��ستخدام APIs المتاحة فقط
         if self.moralis_key and self._is_valid_moralis_key():
             tasks.append(self._get_moralis_token_data(contract_address, network))
         
@@ -977,7 +911,6 @@ class EnhancedWhaleMonitor:
             tasks.append(self._get_etherscan_token_data_v2(contract_address))
         
         if not tasks:
-            print("⚠️ لا توجد مفاتيح API متاحة لجلب بيانات الرموز")
             return await self._get_rpc_token_data(contract_address, network)
             
         results = await asyncio.gather(*tasks, return_exceptions=True)
@@ -988,25 +921,19 @@ class EnhancedWhaleMonitor:
                 all_transfers.extend(res)
         
         if not all_transfers:
-            print("⚠️ فشل جميع APIs، استخدام RPC كبديل")
             return await self._get_rpc_token_data(contract_address, network)
                 
-        print(f"✅ تم جمع {len(all_transfers)} تحويل من APIs")
         return all_transfers
 
     def _is_valid_moralis_key(self):
-        """التحقق من أن مفتاح Moralis صالح"""
         if not self.moralis_key:
             return False
         return len(self.moralis_key) >= 20
 
     async def _get_rpc_token_data(self, contract_address, network='ethereum'):
         try:
-            print(f"🔍 استخدام RPC لجلب بيانات العقد {contract_address} على شبكة {network}")
-            
             endpoint = self._get_next_rpc_endpoint(network)
             if not endpoint:
-                print(f"❌ لا توجد نقاط RPC متاحة لـ {network}")
                 return []
                 
             transfers = []
@@ -1023,8 +950,7 @@ class EnhancedWhaleMonitor:
                 
                 latest_block = int(result, 16)
             
-            # مسح آخر 50 كتلة
-            for block_offset in range(50):
+            for block_offset in range(20):
                 block_number = latest_block - block_offset
                 if block_number < 0:
                     break
@@ -1050,16 +976,13 @@ class EnhancedWhaleMonitor:
                                 'blockNumber': str(block_number)
                             })
             
-            print(f"✅ تم جمع {len(transfers)} تحويل من RPC")
             return transfers
             
         except Exception as e:
-            print(f"❌ فشل جلب بيانات RPC: {e}")
             return []
 
     async def _get_etherscan_token_data_v2(self, contract_address):
         if not self.etherscan_key:
-            print("⚠️ مفتاح Etherscan غير متوفر")
             return []
             
         try:
@@ -1083,38 +1006,26 @@ class EnhancedWhaleMonitor:
                 response = await client.get(base_url, params=params)
                 
                 if response.status_code == 429:
-                    print("⏰ تجاوز حد المعدل في Etherscan")
                     await asyncio.sleep(2)
                     return []
                 elif response.status_code == 401:
-                    print("❌ خطأ في مصادقة Etherscan - المفتاح غير صالح")
                     return []
                 elif response.status_code >= 500:
-                    print(f"❌ خطأ في خادم Etherscan: {response.status_code}")
                     return []
                 
                 response.raise_for_status()
                 data = response.json()
                 
                 if data.get('status') == '1' and data.get('message') == 'OK':
-                    result = data.get('result', [])
-                    print(f"✅ تم جلب {len(result)} تحويل من Etherscan")
-                    return result
+                    return data.get('result', [])
                 else:
-                    error_msg = data.get('result', data.get('message', 'Unknown error'))
-                    print(f"⚠️ استجابة غير متوقعة من Etherscan: {error_msg}")
                     return []
                     
-        except httpx.HTTPStatusError as e:
-            print(f"❌ خطأ HTTP في Etherscan: {e}")
-            return []
         except Exception as e:
-            print(f"❌ خطأ عام في Etherscan: {e}")
             return []
 
     async def _get_moralis_token_data(self, contract_address, network='ethereum'):
         if not self.moralis_key or not self._is_valid_moralis_key():
-            print("⚠️ مفتاح Moralis غير متوفر أو غير صالح")
             return []
             
         try:
@@ -1131,7 +1042,6 @@ class EnhancedWhaleMonitor:
             
             chain_id = chains.get(network)
             if not chain_id:
-                print(f"⚠️ شبكة {network} غير مدعومة في Moralis")
                 return []
             
             all_transfers = []
@@ -1153,25 +1063,19 @@ class EnhancedWhaleMonitor:
                     if response.status_code == 200:
                         result = response.json().get('result', [])
                         all_transfers.extend(result)
-                        print(f"✅ تم جلب {len(result)} تحويل من Moralis ({network})")
                     elif response.status_code == 401:
-                        print(f"❌ خطأ في مصادقة Moralis - المفتاح غير صالح")
                         return []
                     elif response.status_code == 404:
-                        print(f"⚠️ لم يتم العثور على بيانات للعقد {contract_address} على {network}")
                         return []
                     else:
-                        print(f"⚠️ استجابة غير ناجحة من Moralis لـ {network}: {response.status_code}")
                         return []
                         
             except Exception as chain_error:
-                print(f"❌ خطأ في Moralis لـ {network}: {chain_error}")
                 return []
             
             return all_transfers
                 
         except Exception as e:
-            print(f"❌ خطأ عام في Moralis: {e}")
             return []
 
     async def _enrich_api_data_with_timing(self, api_data):
@@ -1211,7 +1115,6 @@ class EnhancedWhaleMonitor:
                 enriched_data.append(enriched_transfer)
                 
             except Exception as e:
-                print(f"⚠️ خطأ في توقيت البيانات: {e}")
                 continue
                 
         return enriched_data
@@ -1232,11 +1135,11 @@ class EnhancedWhaleMonitor:
             
             for transfer in enriched_data:
                 value = float(transfer.get('value', 0))
-                if value > 1e15:  # تحويل من wei إلى ether
+                if value > 1e15:
                     value = value / 1e18
                 volumes.append(value)
                 
-                if value > 10000:  # تحويل كبير
+                if value > 10000:
                     large_transfers.append(transfer)
             
             total_volume = sum(volumes)
@@ -1275,7 +1178,6 @@ class EnhancedWhaleMonitor:
             }
             
         except Exception as e:
-            print(f"❌ خطأ في تحليل بيانات {symbol}: {e}")
             return {
                 'data_available': False,
                 'description': f'غير متوفر - خطأ في تحليل البيانات',
@@ -1292,7 +1194,6 @@ class EnhancedWhaleMonitor:
                 if self.data_manager:
                     native_price = await self.data_manager.get_native_coin_price(network)
                     if native_price:
-                        print(f"✅ تم اكتشاف {symbol} على شبكة {network} - سعر {network.upper()}: ${native_price:.2f}")
                         return {
                             'data_available': True,
                             'description': f'تم اكتشاف {symbol} على شبكة {network}',
@@ -1301,10 +1202,8 @@ class EnhancedWhaleMonitor:
                             'source': 'network_scan'
                         }
             except Exception as e:
-                print(f"⚠️ فشل مسح شبكة {network} لـ {symbol}: {e}")
                 continue
         
-        print(f"❌ لم يتم العثور على {symbol} على أي شبكة")
         return {
             'data_available': False,
             'description': f'غير متوفر - لم يتم العثور على {symbol} على أي شبكة',
@@ -1401,66 +1300,9 @@ class EnhancedWhaleMonitor:
             return signal
             
         except Exception as e:
-            print(f"❌ خطأ في توليد إشارة الحيتان: {e}")
             return None
 
-    async def track_pattern_outcome(self, symbol, pattern_analysis, success, profit_percent):
-        if not pattern_analysis:
-            return
-        
-        pattern_name = pattern_analysis.get('pattern_detected')
-        confidence = pattern_analysis.get('pattern_confidence', 0)
-        
-        if pattern_name not in ['no_clear_pattern', 'insufficient_data']:
-            if pattern_name not in self.pattern_performance:
-                self.pattern_performance[pattern_name] = {
-                    'total_trades': 0,
-                    'successful_trades': 0,
-                    'total_profit': 0,
-                    'total_confidence': 0,
-                    'last_updated': datetime.now().isoformat()
-                }
-            
-            stats = self.pattern_performance[pattern_name]
-            stats['total_trades'] += 1
-            stats['total_confidence'] += confidence
-            stats['last_updated'] = datetime.now().isoformat()
-            
-            if success:
-                stats['successful_trades'] += 1
-                stats['total_profit'] += profit_percent
-
-            if stats['total_trades'] > 0:
-                self.pattern_success_rates[pattern_name] = {
-                    'success_rate': stats['successful_trades'] / stats['total_trades'],
-                    'avg_profit': stats['total_profit'] / stats['total_trades'],
-                    'total_trades': stats['total_trades'],
-                    'last_updated': datetime.now().isoformat()
-                }
-            
-            if stats['total_trades'] % 10 == 0:
-                await self._save_pattern_performance()
-
-            print(f"✅ تم تحديث أداء النمط {pattern_name}: {stats['successful_trades']}/{stats['total_trades']} نجاح")
-
-    def get_pattern_reliability(self, pattern_name):
-        if pattern_name in self.pattern_success_rates:
-            return self.pattern_success_rates[pattern_name]['success_rate']
-        return 0.5
-
-    async def save_all_pattern_data(self):
-        await self._save_pattern_performance()
-
-    def get_pattern_performance_summary(self):
-        return {
-            'pattern_performance': self.pattern_performance,
-            'pattern_success_rates': self.pattern_success_rates,
-            'total_patterns_tracked': len(self.pattern_performance),
-            'last_updated': datetime.now().isoformat()
-        }
-
     async def cleanup(self):
         await self.http_client.aclose()
-        print("✅ تم تنظيف موارد EnhancedWhaleMonitor")
 
 print("✅ EnhancedWhaleMonitor loaded - Real-time whale activity monitoring ready")